import Database from "@Common/databases/database";
import BaseRepository from "@Repositories/BaseRepository";
import { Service } from "typedi";
import { EFolderStatus, OfficeFolders, Prisma } from "@prisma/client";
import { OfficeFolder } from "le-coffre-resources/dist/SuperAdmin";

@Service()
export default class OfficeFoldersRepository extends BaseRepository {
	constructor(private database: Database) {
		super();
	}
	protected get model() {
		return this.database.getClient().officeFolders;
	}
	protected get instanceDb() {
		return this.database.getClient();
	}

	/**
	 * @description : Find many office folders
	 */
	public async findMany(query: any): Promise<OfficeFolders[]> {
		query.take = Math.min(query.take || this.defaultFetchRows, this.maxFetchRows);
		return this.model.findMany(query);
	}

	/**
	 * @description : Create new office folder without customers nor stakeholders
	 */
	public async create(officeFolder: OfficeFolder): Promise<OfficeFolders> {
		const createArgs: Prisma.OfficeFoldersCreateArgs = {
			data: {
				folder_number: officeFolder.folder_number,
				name: officeFolder.name,
				description: officeFolder.description,
				status: EFolderStatus.LIVE,
				deed: {
					create: {
						deed_type: {
							connect: {
								uuid: officeFolder.deed.deed_type.uid,
							},
						},
					},
				},
				office: {
					connect: {
						idNot: officeFolder.office.idNot,
					},
				},
			},
			include: {
				office_folder_has_stakeholder: true,
			}
		};
		if (officeFolder.office_folder_has_stakeholder) {
			createArgs.data.office_folder_has_stakeholder = {
				createMany: {
					data: officeFolder.office_folder_has_stakeholder.map((relation) => ({
						user_stakeholder_uuid: relation.user_stakeholder.uid,
					})),
					skipDuplicates: true
				},
			};
		}
		return this.model.create(createArgs);
	}

	/**
	 * @description : Update data of an office folder
	 */
	public async update(officeFolderUuid: string, officeFolder: OfficeFolder): Promise<OfficeFolders> {
		const updateArgs: Prisma.OfficeFoldersUpdateArgs = {
			where: {
				uuid: officeFolderUuid,
			},
			data: {
				folder_number: officeFolder.folder_number,
				name: officeFolder.name,
				description: officeFolder.description,
				status: EFolderStatus[officeFolder.status as keyof typeof EFolderStatus],
				archived_description: officeFolder.archived_description,
			},
			include: {
				office_folder_has_stakeholder: true,
				office_folder_has_customers: true,
				documents: true,
			}
		};
		if (officeFolder.office_folder_has_stakeholder) {
			updateArgs.data.office_folder_has_stakeholder = {
				deleteMany: { office_folder_uuid: officeFolderUuid },
				createMany: {
					data: officeFolder.office_folder_has_stakeholder.map((relation) => ({
						user_stakeholder_uuid: relation.user_stakeholder.uid,
					})),
					skipDuplicates: true
				},
			}
		}
		if (officeFolder.office_folder_has_customers) {
			updateArgs.data.office_folder_has_customers = {
				deleteMany: { office_folder_uuid: officeFolderUuid },
				createMany: {
					data: officeFolder.office_folder_has_customers.map((relation) => ({
						customer_uuid: relation.customer.uid,
					})),
					skipDuplicates: true
				},
			}
		}
		if (officeFolder.documents) {
			updateArgs.data.documents = {
				createMany: {
					data: officeFolder.documents.map((relation) => ({
						document_type_uuid: relation.document_type.uid,
						depositor_uuid: relation.depositor.uid
					})),
					skipDuplicates: true
				},
			}
		}
		return this.model.update(updateArgs);
	}

	/**
	 * @description : Find one office folder
	 */
	public async findOneByUid(uid: string): Promise<OfficeFolders> {
		const officeFolderEntity = await this.model.findUnique({
			where: {
				uuid: uid,
			},
		});

		if (!officeFolderEntity) {
			throw new Error("office folder not found");
		}

		return officeFolderEntity;
	}
}