/* eslint-disable @typescript-eslint/no-unused-vars */
import { AxiosResponse } from "axios";
import { instance } from "./axios";

// Models
import {
	RescomCollaboratorsFiltersResponse,
	RescomContractsFiltersResponse,
	RescomProjectsFiltersResponse,
} from "../models/Rescom/RescomFilters";
import {RecordsResponse} from "../models/Axios";
import { GetRescomProjectParams, RescomProject } from "../models/Rescom/RescomProjects";
import {ContractMessage, GetRescomContractsParams, RescomContract} from "../models/Rescom/RescomContracts";
import {GetFilesParams, PersonalFolderFile} from "../models/HrSupport/PersonalFolder";
import {CustomSelectOptions} from "../models/ReactComponents";
import {
	Deal, DealForm,
	GetDealsParams,
	GetRescomCollaboratorsParams,
	RescomCollaborator
} from "../models/Rescom/RescomCollaborator";

/* --------------------------------- */
/*            Stats                  */
/* --------------------------------- */
export async function getRescomStats(unit_id: any) {
	return instance.get("api/rescom/v1/organization/statistics", {
		params: { unit_id },
	});
}

/* --------------------------------- */
/*           Projects                */
/* --------------------------------- */
export function getRescomProjects(params: GetRescomProjectParams) {
	return instance.post<RecordsResponse<RescomProject>>("/api/rescom/v1/projects/list", params);
}

export function getRescomProjectsFilters(activeRole: string | null) {
	return instance.get<RescomProjectsFiltersResponse>("/api/rescom/v1/projects/filters", {
		headers: { "Cache-Control": "no-cache", Pragma: "no-cache" },
		params: { t: Date.now(), role: activeRole }, // cache-buster
	});
}

export function getRescomCollaboratorsFilters(activeRole: string | null) {
	return instance.get<RescomCollaboratorsFiltersResponse>("/api/rescom/v1/collaborators/filters", {
		headers: { "Cache-Control": "no-cache", Pragma: "no-cache" },
		params: { t: Date.now(), role: activeRole }, // cache-buster
	});
}

export async function getSingleProject(id: any) {
	return instance.get<RescomProject>(`api/rescom/v1/projects/project/${id}`, {
		headers: { "Cache-Control": "no-cache", Pragma: "no-cache" },
		params: { t: Date.now() },
	});
}

export async function getSingleProjectManagers(id: any, unit_code: any) {
	return instance.get<RescomProject>(
		`api/rescom/v1/researcher/projects/project/${id}/unit/${unit_code}/managers`
	);
}

export async function getSingleProjectSnapshots(project_code: string | number) {
	const response = await instance.get<RescomProject>(
		`api/rescom/v1/projects/project/${project_code}/a1/snapshots`
	);
	return response.data;
}
export async function getSingleProjectWorkPackages(project_code: string | number) {
	const response = await instance.get<RescomProject>(
		`api/rescom/v1/projects/project/${project_code}/get/workPackages`
	);
	return response.data;
}




export async function updateSingleProject(formData: any) {
	return instance.post(`api/rescom/v1/projects/project/update/extra`, formData);
}

export async function updateSingleProjectManagers(id: any, formData: any) {
	return instance.post(`api/rescom/v1/projects/project/${id}/managers/update`, formData);
}

type SnapshotPayload = {
	project_code: string;
	snapshot_dates: { title: string; date: string }[];
};

type WorkPackagePayload = {
	project_code: string;
	work_packages: { title: string}[];
};

export async function updateSingleProjectSnapshots(payload: SnapshotPayload): Promise<AxiosResponse> {
	return instance.post(
		`api/rescom/v1/projects/project/${payload.project_code}/update/snapshots`,
		{ snapshot_dates: payload.snapshot_dates }
	);
}

export async function updateSingleProjectWorkPackages(payload: WorkPackagePayload): Promise<AxiosResponse> {
	return instance.post(
		`api/rescom/v1/projects/project/${payload.project_code}/addOrUpdate/workPackages`,
		{ work_packages: payload.work_packages }
	);
}

export async function getA1Categories() {
	return instance.get<any>(`api/rescom/v1/projects/a1/categories`);
}

/* --------------------------------- */
/*           Contracts               */
/* --------------------------------- */
export function getRescomContracts(params: GetRescomContractsParams) {
	return instance.post<RecordsResponse<RescomContract>>("/api/rescom/v1/contracts/list", params);
}

export function getRescomContractsUserAll(params: GetRescomContractsParams) {
	return instance.post<RecordsResponse<RescomContract>>("/api/rescom/v1/contracts/list", params);
}
export function getRescomContractsFilters(activeRole: string | null) {
	return instance.get<RescomContractsFiltersResponse>("/api/rescom/v1/contracts/filters", {
		headers: { "Cache-Control": "no-cache", Pragma: "no-cache" },
		params: { t: Date.now(), role: activeRole }, // cache-buster
	});
}

export async function getSingleContract(contract_code: any) {
	return instance.get<RescomContract>(`api/rescom/v1/contracts/contract/${contract_code}`);
}

export async function updateContractWorkPackages(id: any, formData: any) {
	return instance.post(`api/rescom/v1/contracts/contract/${id}/addOrUpdate/workPackages`, formData);
}

export async function getSingleContractWorkPackages(contract_code: string | number, project_code: string | number) {
	const response = await instance.get<any>(
		`api/rescom/v1/contracts/contract/${contract_code}/project/${project_code}/WorkPackages`

	);
	return response.data;
}
export async function getSingleContractMessages(contract_code: any) {
	return instance.get<ContractMessage[]>(`api/rescom/v1/contracts/contract/messages/${contract_code}`);
}

export async function getSingleContractAmendments(id: any) {
	return instance.get<RescomContract>(`api/rescom/v1/researcher/contracts/amendments/${id}`);
}

export async function updateContractColumns(formData: any) {
	return instance.post(`api/rescom/v1/contracts/contract/update/extra`, formData);
}

export async function AddContractMessage(formData: any) {
	return instance.post(`api/rescom/v1/contracts/contract/messages/add`, formData);
}

export async function DeleteContractMessage(id: any) {
	return instance.post(`api/rescom/v1/contracts/contract/messages/delete/${id}`);
}

/* --------------------------------- */
/*           Employees               */
/* --------------------------------- */
export function getRescomCollaborators(params: GetRescomCollaboratorsParams) {
	return instance.post<RecordsResponse<RescomCollaborator>>("api/rescom/v1/collaborators/list", params);
}

export async function getDeals(dealsParams:GetDealsParams) {
	return instance.get<RecordsResponse<Deal>>("api/rescom/v1/collaborators/amount/list",
		{params: dealsParams});
}

export async function addDeal(params: DealForm) {
	return instance.post<Deal>("api/rescom/v1/collaborators/add/amount", params);
}

export async function updateDeal(id: string | number, payload: DealForm) {
	return instance.post<Deal>(`api/rescom/v1/collaborators/update/amount/${id}`, payload);
}

export async function updateSpeciality(formData: any) {
	return instance.post(`api/rescom/v1/collaborators/add/project_specialization`, formData);
}


export function getCollaboratorMessages(collaborator_afm: any) {
	return instance.get<ContractMessage[]>(
		`api/rescom/v1/collaborators/collaborator/messages`,
		{ params: { afm: collaborator_afm } }
	);
}

export async function AddCollaboratorMessage(formData: any) {
	return instance.post(`api/rescom/v1/collaborators/collaborator/add/messages`, formData);
}

export async function DeleteCollaboratorMessage(id: any) {
	return instance.post(`api/rescom/v1/collaborators/collaborator/delete/messages/${id}`);
}

/* --------------------------------- */
/*           Project Contracts       */
/* --------------------------------- */
interface RescomSymvaseisErgouParams {
	page: number;
	project_id: string | undefined;
	page_size?: number;
}
/* --------------------------------- */
/*           Users                   */
/* --------------------------------- */
export function getUserIdByAfm(anchor: string) {
	return instance.get("api/rescom/v1/contracts/identify/user", {params: {afm: anchor}});
}


export const checkUnitHasHr = (unit_code: any) => {
	return instance.get(`api/hr-settings/unit/${unit_code}/has-hr`);
};

export async function sendDuaInvite(params: any) {
	return instance.post("api/rescom/v1/collaborators/collaborator/invite", params);
}

/* --------------------------------- */
/*           Folder                   */
/* --------------------------------- */


export async function getUserFilesProject(params: GetFilesParams) {
	return instance.post<RecordsResponse<PersonalFolderFile>>("api/rescom/v1/contracts/personalFolder/list", params);
}

export async function getPersonnelSingleProject(id: any, role:string, project_code:string) {
	return instance.get(`api/rescom/v1/contracts/personnel/${id}`, {
		params: {
			role: role,
			project_code:project_code
		},
	});
}

export async function uploadFileRescom(params: any) {
	return instance.post("api/rescom/v1/files/store/file", params);
}



export async function downloadFileRescom(filepath: string, project_code:string, role:string) {
	return instance.get("api/rescom/v1/files/download/file", {
		params: {
			filepath: filepath,
			project_code:project_code,
			role:role
		},
		responseType: 'blob',
	});
}

export async function deleteFileRescom(uuid: string, filepath: string, project_code:string, role:string) {
	return instance.post("api/rescom/v1/files/delete/files", {
		uuid: uuid,
		filepath: filepath,
		project_code:project_code,
		role:role
	});
}


export async function replaceFileRescom(params: any) {
	return instance.post("api/rescom/v1/files/replace/file", params);
}
export async function editFileRescom(filepath: string, subject: string, protocol_number: string, project_code:string, role:string) {
	return instance.post("api/rescom/v1/files/update/fields", {
		filepath: filepath,
		subject: subject,
		protocol_number: protocol_number,
		project_code:project_code,
		role:role
	});
}

//deletes file and any attachments it has if any
export async function moveFileRescom(filepath: string, subfolder_id: number, project_code:string, role:string) {
	return instance.post("api/rescom/v1/files/move/file", {
		filepath: filepath,
		subfolder_id: subfolder_id,
		project_code:project_code,
		role:role
	});
}

export async function getContractsLookupRescom(user_id: any,role:any, project_code:string, authUserId:any ) {
	return instance.get<CustomSelectOptions>(`api/rescom/v1/contracts/personnel/${user_id}/contract/codes`, {
		params: {
			role:role,
			project_code:project_code,
			auth_user_id:authUserId
		},
	});
}

// MOCK: Fetch project codes for the logged-in user
// ---------------------------------
//     User Project Codes (MOCK)
// ---------------------------------

export function getUserProjectCodes(activeRole: string) {
	return instance.get(
		"/api/rescom/v1/collaborators/managing/project-codes",
		{
			params: { active_role: activeRole },
		}
	);
}

export async function startHrOffboarding(params: any) {
	return instance.post<any>(`api/rescom/v1/collaborators/addOffBoarding`, params);
}


export function getCollaborator(id: string | number) {
	return instance.get(`api/rescom/v1/collaborators/collaborator/details/${id}`);
}