import type { EntityTarget } from 'typeorm';
import { container, Service } from '../../core/container';
import { Database, getManager } from '../../core/database';
import { Author } from '../../entities/library/author';
import { AuthorName } from '../../entities/library/author-name';
import { AuthorRole } from '../../entities/library/author-role';
import { AuthorRoleName } from '../../entities/library/author-role-name';
import { CharacterTag } from '../../entities/library/character-tag';
import { Collection } from '../../entities/library/collection';
import { CollectionName } from '../../entities/library/collection-name';
import { CollectionPart } from '../../entities/library/collection-part';
import { Copy } from '../../entities/library/copy';
import { InteractionTag } from '../../entities/library/interaction-tag';
import { Site } from '../../entities/library/site';
import { SiteName } from '../../entities/library/site-name';
import { Source } from '../../entities/library/source';
import { Tag } from '../../entities/library/tag';
import { TagName } from '../../entities/library/tag-name';
import { Transformation } from '../../entities/library/transformation';
import { TransformationType } from '../../entities/library/transformation-type';
import { TransformationTypeName } from '../../entities/library/transformation-type-name';
import { Work } from '../../entities/library/work';
import { WorkAuthor } from '../../entities/library/work-author';
import { WorkCharacter } from '../../entities/library/work-character';
import { WorkCharacterName } from '../../entities/library/work-character-name';
import { WorkName } from '../../entities/library/work-name';
import { WorkTag } from '../../entities/library/work-tag';
import { World } from '../../entities/library/world';
import { WorldCharacter } from '../../entities/library/world-character';
import { WorldCharacterName } from '../../entities/library/world-character-name';
import { WorldName } from '../../entities/library/world-name';
import { ipcServer } from '../ipc/ipc-server';
import type { Serializer } from '../serialization/serializer';

type CreateSerializedType = {
  [IpcChannel.ENTITY_CREATE_AUTHOR]: AuthorSerializedInterface;
  [IpcChannel.ENTITY_CREATE_AUTHOR_NAME]: AuthorNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_AUTHOR_ROLE]: AuthorRoleSerializedInterface;
  [IpcChannel.ENTITY_CREATE_AUTHOR_ROLE_NAME]: AuthorRoleNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_CHARACTER_TAG]: CharacterTagSerializedInterface;
  [IpcChannel.ENTITY_CREATE_COLLECTION]: CollectionSerializedInterface;
  [IpcChannel.ENTITY_CREATE_COLLECTION_NAME]: CollectionNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_COLLECTION_PART]: CollectionPartSerializedInterface;
  [IpcChannel.ENTITY_CREATE_COPY]: CopySerializedInterface;
  [IpcChannel.ENTITY_CREATE_INTERACTION_TAG]: InteractionTagSerializedInterface;
  [IpcChannel.ENTITY_CREATE_SITE]: SiteSerializedInterface;
  [IpcChannel.ENTITY_CREATE_SITE_NAME]: SiteNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_SOURCE]: SourceSerializedInterface;
  [IpcChannel.ENTITY_CREATE_TAG]: TagSerializedInterface;
  [IpcChannel.ENTITY_CREATE_TAG_NAME]: TagNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_TRANSFORMATION]: TransformationSerializedInterface;
  [IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE]: TransformationTypeSerializedInterface;
  [IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE_NAME]: TransformationTypeNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORK_AUTHOR]: WorkAuthorSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORK_CHARACTER]: WorkCharacterSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORK_CHARACTER_NAME]: WorkCharacterNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORK]: WorkSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORK_NAME]: WorkNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORK_TAG]: WorkTagSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORLD]: WorldSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORLD_NAME]: WorldNameSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORLD_CHARACTER]: WorldCharacterSerializedInterface;
  [IpcChannel.ENTITY_CREATE_WORLD_CHARACTER_NAME]: WorldCharacterNameSerializedInterface;
};

type CreateEntityType = {
  [IpcChannel.ENTITY_CREATE_AUTHOR]: Author;
  [IpcChannel.ENTITY_CREATE_AUTHOR_NAME]: AuthorName;
  [IpcChannel.ENTITY_CREATE_AUTHOR_ROLE]: AuthorRole;
  [IpcChannel.ENTITY_CREATE_AUTHOR_ROLE_NAME]: AuthorRoleName;
  [IpcChannel.ENTITY_CREATE_CHARACTER_TAG]: CharacterTag;
  [IpcChannel.ENTITY_CREATE_COLLECTION]: Collection;
  [IpcChannel.ENTITY_CREATE_COLLECTION_NAME]: CollectionName;
  [IpcChannel.ENTITY_CREATE_COLLECTION_PART]: CollectionPart;
  [IpcChannel.ENTITY_CREATE_COPY]: Copy;
  [IpcChannel.ENTITY_CREATE_INTERACTION_TAG]: InteractionTag;
  [IpcChannel.ENTITY_CREATE_SITE]: Site;
  [IpcChannel.ENTITY_CREATE_SITE_NAME]: SiteName;
  [IpcChannel.ENTITY_CREATE_SOURCE]: Source;
  [IpcChannel.ENTITY_CREATE_TAG]: Tag;
  [IpcChannel.ENTITY_CREATE_TAG_NAME]: TagName;
  [IpcChannel.ENTITY_CREATE_TRANSFORMATION]: Transformation;
  [IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE]: TransformationType;
  [IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE_NAME]: TransformationTypeName;
  [IpcChannel.ENTITY_CREATE_WORK_AUTHOR]: WorkAuthor;
  [IpcChannel.ENTITY_CREATE_WORK_CHARACTER]: WorkCharacter;
  [IpcChannel.ENTITY_CREATE_WORK_CHARACTER_NAME]: WorkCharacterName;
  [IpcChannel.ENTITY_CREATE_WORK]: Work;
  [IpcChannel.ENTITY_CREATE_WORK_NAME]: WorkName;
  [IpcChannel.ENTITY_CREATE_WORK_TAG]: WorkTag;
  [IpcChannel.ENTITY_CREATE_WORLD]: World;
  [IpcChannel.ENTITY_CREATE_WORLD_NAME]: WorldName;
  [IpcChannel.ENTITY_CREATE_WORLD_CHARACTER]: WorldCharacter;
  [IpcChannel.ENTITY_CREATE_WORLD_CHARACTER_NAME]: WorldCharacterName;
};

async function create<T extends keyof CreateSerializedType>(
  partial: Partial<CreateSerializedType[T]>,
  entityTarget: EntityTarget<CreateEntityType[T]>,
  serializer: Serializer<CreateEntityType[T], CreateSerializedType[T]>,
): Promise<CreateSerializedType[T]> {
  const manager = await getManager(Database.LIBRARY);
  const entity = manager.create(entityTarget, serializer.deserialize(partial) as DeepPartial<CreateEntityType[T]>);
  return serializer.serialize(await manager.save(entity));
}

ipcServer.answer(IpcChannel.ENTITY_CREATE_AUTHOR, (partial) =>
  create<IpcChannel.ENTITY_CREATE_AUTHOR>(partial, Author, container.get(Service.AUTHOR_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_AUTHOR_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_AUTHOR_NAME>(partial, AuthorName, container.get(Service.AUTHOR_NAME_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_AUTHOR_ROLE, (partial) =>
  create<IpcChannel.ENTITY_CREATE_AUTHOR_ROLE>(partial, AuthorRole, container.get(Service.AUTHOR_ROLE_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_AUTHOR_ROLE_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_AUTHOR_ROLE_NAME>(
    partial,
    AuthorRoleName,
    container.get(Service.AUTHOR_ROLE_NAME_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_CHARACTER_TAG, (partial) =>
  create<IpcChannel.ENTITY_CREATE_CHARACTER_TAG>(
    partial,
    CharacterTag,
    container.get(Service.CHARACTER_TAG_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_COLLECTION, (partial) =>
  create<IpcChannel.ENTITY_CREATE_COLLECTION>(partial, Collection, container.get(Service.COLLECTION_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_COLLECTION_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_COLLECTION_NAME>(
    partial,
    CollectionName,
    container.get(Service.COLLECTION_NAME_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_COLLECTION_PART, (partial) =>
  create<IpcChannel.ENTITY_CREATE_COLLECTION_PART>(
    partial,
    CollectionPart,
    container.get(Service.COLLECTION_PART_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_COPY, (partial) =>
  create<IpcChannel.ENTITY_CREATE_COPY>(partial, Copy, container.get(Service.COPY_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_INTERACTION_TAG, (partial) =>
  create<IpcChannel.ENTITY_CREATE_INTERACTION_TAG>(
    partial,
    InteractionTag,
    container.get(Service.INTERACTION_TAG_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_SITE, (partial) =>
  create<IpcChannel.ENTITY_CREATE_SITE>(partial, Site, container.get(Service.SITE_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_SITE_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_SITE_NAME>(partial, SiteName, container.get(Service.SITE_NAME_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_SOURCE, (partial) =>
  create<IpcChannel.ENTITY_CREATE_SOURCE>(partial, Source, container.get(Service.SOURCE_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_TAG, (partial) =>
  create<IpcChannel.ENTITY_CREATE_TAG>(partial, Tag, container.get(Service.TAG_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_TAG_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_TAG_NAME>(partial, TagName, container.get(Service.TAG_NAME_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_TRANSFORMATION, (partial) =>
  create<IpcChannel.ENTITY_CREATE_TRANSFORMATION>(
    partial,
    Transformation,
    container.get(Service.TRANSFORMATION_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE, (partial) =>
  create<IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE>(
    partial,
    TransformationType,
    container.get(Service.TRANSFORMATION_TYPE_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_TRANSFORMATION_TYPE_NAME>(
    partial,
    TransformationTypeName,
    container.get(Service.TRANSFORMATION_TYPE_NAME_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORK_AUTHOR, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORK_AUTHOR>(partial, WorkAuthor, container.get(Service.WORK_AUTHOR_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORK_CHARACTER, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORK_CHARACTER>(
    partial,
    WorkCharacter,
    container.get(Service.WORK_CHARACTER_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORK_CHARACTER_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORK_CHARACTER_NAME>(
    partial,
    WorkCharacterName,
    container.get(Service.WORK_CHARACTER_NAME_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORK, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORK>(partial, Work, container.get(Service.WORK_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORK_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORK_NAME>(partial, WorkName, container.get(Service.WORK_NAME_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORK_TAG, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORK_TAG>(partial, WorkTag, container.get(Service.WORK_TAG_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORLD, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORLD>(partial, World, container.get(Service.WORLD_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORLD_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORLD_NAME>(partial, WorldName, container.get(Service.WORLD_NAME_SERIALIZER)),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORLD_CHARACTER, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORLD_CHARACTER>(
    partial,
    WorldCharacter,
    container.get(Service.WORLD_CHARACTER_SERIALIZER),
  ),
);

ipcServer.answer(IpcChannel.ENTITY_CREATE_WORLD_CHARACTER_NAME, (partial) =>
  create<IpcChannel.ENTITY_CREATE_WORLD_CHARACTER_NAME>(
    partial,
    WorldCharacterName,
    container.get(Service.WORLD_CHARACTER_NAME_SERIALIZER),
  ),
);