import "module-alias/register";
import "reflect-metadata";
import { OfficeFolderHasCustomers, OfficeFolderHasStakeholders, PrismaClient } from "prisma/prisma-client";
import { customer, customer_, deedType, documentType, documentType_, office, officeFolder, officeFolder_, user, user_ } from "@Test/config/MockedData";
import Container from "typedi";
import OfficeFoldersRepository from "@Repositories/OfficeFoldersRepository";
import OfficeFolderService from "@Services/super-admin/OfficeFoldersService/OfficeFoldersService";
import { initCustomers, initDeedType, initDocumentType, initOffice, initUsers } from "@Test/config/Init";
import { OfficeFolder } from "le-coffre-resources/dist/SuperAdmin";
import DeedTypesService from "@Services/super-admin/DeedTypesService/DeedTypesService";
import DeedsRepository from "@Repositories/DeedsRepository";

const prisma = new PrismaClient();

const OfficeFolderServiceTest = new OfficeFolderService(Container.get(OfficeFoldersRepository), Container.get(DeedTypesService), Container.get(DeedsRepository));

beforeAll(async () => {
	office.uid = (await initOffice(office)).uid;
	documentType.uid = (await initDocumentType(documentType, office)).uid;
	documentType_.uid = (await initDocumentType(documentType_, office)).uid;
	deedType.uid = (await initDeedType(deedType, office, [documentType.uid])).uid;
	user.uid = (await initUsers(user)).uid;
	user_.uid = (await initUsers(user_)).uid;
	customer.uid = (await initCustomers(customer)).uid;
	customer_.uid = (await initCustomers(customer_)).uid;
});

afterAll(async () => {
	/*
	 * Clean database after all tests execution.
	 * Due to cascade deletion, if addresses are deleted, all items following tables are dropped: contacts, customers, offices
	 */
	const deleteDeedTypes = prisma.deedTypes.deleteMany();
	const deleteAddresses = prisma.addresses.deleteMany();
	await prisma.$transaction([deleteDeedTypes, deleteAddresses]);
	await prisma.$disconnect();
});

describe("test create function", () => {
	it("should not create a new office folder if deed type is unknown", async () => {
		let officeFolderWithoutDeedTypeUid: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
		officeFolderWithoutDeedTypeUid.deed!.deed_type!.uid = "random uid";
		// try to create a new deed with unknown deed type
		async function createOfficeFolderWithUnknownDeedType() {
			await OfficeFolderServiceTest.create(officeFolderWithoutDeedTypeUid);
		}
		await expect(createOfficeFolderWithUnknownDeedType).rejects.toThrow();
	});

	it("should not create a new office folder if deed type is archived", async () => {
	let officeFolderWithArchivatedDeedType: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
		// try to create a new deed with unknown deed type
		async function createOfficeFolderWithArchivedDeedType() {
			await OfficeFolderServiceTest.create(officeFolderWithArchivatedDeedType);
		}
		await expect(createOfficeFolderWithArchivedDeedType).rejects.toThrow("deed type is archived");
	});

	it("should create a new office folder based on existing deed type", async () => {
		const officeFolderCreated = await OfficeFolderServiceTest.create(officeFolder);

		const deedCreated = await prisma.deeds.findUniqueOrThrow({ where: { uid: officeFolderCreated.deed_uid } });

		expect(officeFolderCreated.name).toEqual(officeFolder.name);
		expect(officeFolderCreated.folder_number).toEqual(officeFolder.folder_number);
		expect(officeFolderCreated.description).toEqual(officeFolder.description);
		expect(officeFolderCreated.archived_description).toEqual(null);
		expect(officeFolderCreated.status).toEqual("LIVE");
		expect(officeFolderCreated.office_uid).toEqual(officeFolder.office!.uid);
		expect(deedCreated.deed_type_uid).toEqual(officeFolder.deed!.deed_type!.uid);
	});

	it("should contains stakeholders", async () => {
		const officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { office_folder_has_stakeholder: true },
		});
		const stakeholderRelation = await prisma.officeFolderHasStakeholders.findUniqueOrThrow({
			where: {
				office_folder_uid_user_stakeholder_uid: {
					user_stakeholder_uid: user.uid!,
					office_folder_uid: officeFolderCreated.uid,
				},
			},
		});
		const stakeholderRelation_ = await prisma.officeFolderHasStakeholders.findUniqueOrThrow({
			where: {
				office_folder_uid_user_stakeholder_uid: {
					user_stakeholder_uid: user_.uid!,
					office_folder_uid: officeFolderCreated.uid,
				},
			},
		});
		expect(officeFolderCreated.office_folder_has_stakeholder.length).toEqual(2);
		const stakeholder: OfficeFolderHasStakeholders = {
			uid: stakeholderRelation.uid,
			office_folder_uid: officeFolderCreated.uid,
			user_stakeholder_uid: user.uid!,
			created_at: officeFolderCreated.created_at,
			updated_at: officeFolderCreated.updated_at,
		};
		const stakeholder_: OfficeFolderHasStakeholders = {
			uid: stakeholderRelation_.uid,
			office_folder_uid: officeFolderCreated.uid,
			user_stakeholder_uid: user_.uid!,
			created_at: officeFolderCreated.created_at,
			updated_at: officeFolderCreated.updated_at,
		};
		expect(officeFolderCreated.office_folder_has_stakeholder).toEqual(expect.arrayContaining([stakeholder, stakeholder_]));
	});

	it("should not create a new office folder with folder number already created", async () => {
		let officeFolderWithSameFolderNumber: OfficeFolder = JSON.parse(JSON.stringify(officeFolder_));
		officeFolderWithSameFolderNumber.folder_number = officeFolder.folder_number;
		// try to create a new deed with unknown deed type
		async function createOfficeFolderWithSameFolderNumber() {
			await OfficeFolderServiceTest.create(officeFolderWithSameFolderNumber);
		}
		await expect(createOfficeFolderWithSameFolderNumber).rejects.toThrow();
	});

	it("should not create a new office folder if deed type is archived", async () => {
		await prisma.deedTypes.update({ where: { uid: deedType.uid }, data: { archived_at: new Date(Date.now()) } });
		// try to create a new deed with archivated deed type
		async function createDeedWithArchivatedDeedType() {
			await OfficeFolderServiceTest.create(officeFolder);
		}
		await expect(createDeedWithArchivatedDeedType).rejects.toThrow("deed type is archived");
	});
});

describe("test update function", () => {
	it("should add customers", async () => {
		let officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { office_folder_has_customers: true },
		});

		expect(officeFolderCreated.office_folder_has_customers).toEqual([]);
		// mocked data contains the customers
		await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolder);

		const customerRelation = await prisma.officeFolderHasCustomers.findUniqueOrThrow({
			where: {
				office_folder_uid_customer_uid: {
					customer_uid: customer.uid!,
					office_folder_uid: officeFolderCreated.uid,
				},
			},
		});
		const customerRelation_ = await prisma.officeFolderHasCustomers.findUniqueOrThrow({
			where: {
				office_folder_uid_customer_uid: {
					customer_uid: customer_.uid!,
					office_folder_uid: officeFolderCreated.uid,
				},
			},
		});

		officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { office_folder_has_customers: true },
		});

		expect(officeFolderCreated.office_folder_has_customers.length).toEqual(2);
		const officeFolderHasCustomer: OfficeFolderHasCustomers = {
			uid: customerRelation.uid,
			office_folder_uid: officeFolderCreated.uid,
			customer_uid: customer.uid!,
			created_at: customerRelation.created_at,
			updated_at: customerRelation.updated_at,
		};
		const officeFolderHasCustomer_: OfficeFolderHasCustomers = {
			uid: customerRelation_.uid,
			office_folder_uid: officeFolderCreated.uid,
			customer_uid: customer_.uid!,
			created_at: customerRelation_.created_at,
			updated_at: customerRelation_.updated_at,
		};
		expect(officeFolderCreated.office_folder_has_customers).toEqual(
			expect.arrayContaining([officeFolderHasCustomer, officeFolderHasCustomer_]),
		);
	});

	it("should remove customers", async () => {
		let officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { office_folder_has_customers: true },
		});

		expect(officeFolderCreated.office_folder_has_customers.length).toEqual(2);

		let officeFolderWithLessCustomers: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
		officeFolderWithLessCustomers.office_folder_has_customers!.pop();
		// mocked data contains the customers
		await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderWithLessCustomers);

		const customerRelation = await prisma.officeFolderHasCustomers.findUniqueOrThrow({
			where: {
				office_folder_uid_customer_uid: {
					customer_uid: customer.uid!,
					office_folder_uid: officeFolderCreated.uid,
				},
			},
		});

		officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { office_folder_has_customers: true },
		});

		expect(officeFolderCreated.office_folder_has_customers.length).toEqual(1);
		const officeFolderHasCustomer: OfficeFolderHasCustomers = {
			uid: customerRelation.uid,
			office_folder_uid: officeFolderCreated.uid,
			customer_uid: customer.uid!,
			created_at: customerRelation.created_at,
			updated_at: customerRelation.updated_at,
		};
		expect(officeFolderCreated.office_folder_has_customers).toEqual([officeFolderHasCustomer]);
	});
	it("should remove stakeholders", async () => {
		let officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { office_folder_has_stakeholder: true },
		});

		expect(officeFolderCreated.office_folder_has_stakeholder.length).toEqual(2);

		let officeFolderWithLessStakeholders: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
		officeFolderWithLessStakeholders.office_folder_has_stakeholder!.pop();
		// mocked data contains the customers
		await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderWithLessStakeholders);

		const stakeholderRelation = await prisma.officeFolderHasStakeholders.findUniqueOrThrow({
			where: {
				office_folder_uid_user_stakeholder_uid: {
					user_stakeholder_uid: user.uid!,
					office_folder_uid: officeFolderCreated.uid,
				},
			},
		});

		officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { office_folder_has_stakeholder: true },
		});

		expect(officeFolderCreated.office_folder_has_stakeholder.length).toEqual(1);
		const officeFolderHasStakeholder: OfficeFolderHasStakeholders = {
			uid: stakeholderRelation.uid,
			office_folder_uid: officeFolderCreated.uid,
			user_stakeholder_uid: user.uid!,
			created_at: stakeholderRelation.created_at,
			updated_at: stakeholderRelation.updated_at,
		};
		expect(officeFolderCreated.office_folder_has_stakeholder).toEqual([officeFolderHasStakeholder]);
	});
	it("should archivate an office folder", async () => {
		const officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({});
		let officeFolderArchived: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
		// mocked data for this office folder is "ARCHIVATED" by default
		officeFolderArchived.archived_description = "folder complete";

		const officeFolderUpdated = await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderArchived);

		expect(officeFolderUpdated.archived_description).toEqual(officeFolderArchived.archived_description);
		expect(officeFolderUpdated.status).toEqual("ARCHIVED");
	});
	it("should unarchivate an office folder", async () => {
		const officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({});

		expect(officeFolderCreated.archived_description).toEqual("folder complete");
		expect(officeFolderCreated.status).toEqual("ARCHIVED");

		let officeFolderUnarchived: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
		officeFolderUnarchived.status = "LIVE";

		const officeFolderUpdated = await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderUnarchived);

		expect(officeFolderUpdated.archived_description).toBeNull();
		expect(officeFolderUpdated.status).toEqual("LIVE");
	});
});

describe("test get function", () => {
	it("should return an array of officeFolders", async () => {
		const officeFolders = await OfficeFolderServiceTest.get({});

		// verify result typing
		expect(officeFolders).toBeInstanceOf(Array<OfficeFolder>);
		expect(officeFolders.length).toEqual(1);
	});
});