import { type EmptyFields } from "@tailor-platform/erp-kit/core";
import { type TailorAnyDBField } from "@tailor-platform/sdk";
import type { TailorDBInsertable } from "@tailor-platform/sdk/kysely";
import type { defineModule as defineOrganizationModule } from "../organization";
import type { defineModule as defineUserManagementModule } from "../user-management";
import { abolishPosition } from "./command/abolishPosition.generated";
import { applyDueAppointments } from "./command/applyDueAppointments.generated";
import { createAppointmentType } from "./command/createAppointmentType.generated";
import { createAssignment } from "./command/createAssignment.generated";
import { createEmploymentType } from "./command/createEmploymentType.generated";
import { createJobProfile } from "./command/createJobProfile.generated";
import { createPosition } from "./command/createPosition.generated";
import { createWorker } from "./command/createWorker.generated";
import { createWorkerEmployment } from "./command/createWorkerEmployment.generated";
import { createWorkRegime } from "./command/createWorkRegime.generated";
import { createWorkSchedule } from "./command/createWorkSchedule.generated";
import { deactivateAppointmentType } from "./command/deactivateAppointmentType.generated";
import { deactivateEmploymentType } from "./command/deactivateEmploymentType.generated";
import { deactivateWorkRegime } from "./command/deactivateWorkRegime.generated";
import { deleteJobProfile } from "./command/deleteJobProfile.generated";
import { endAssignment } from "./command/endAssignment.generated";
import { endWorkSchedule } from "./command/endWorkSchedule.generated";
import { reactivateAppointmentType } from "./command/reactivateAppointmentType.generated";
import { reactivateEmploymentType } from "./command/reactivateEmploymentType.generated";
import { reactivateWorkRegime } from "./command/reactivateWorkRegime.generated";
import { recordAppointment } from "./command/recordAppointment.generated";
import { terminateWorkerEmployment } from "./command/terminateWorkerEmployment.generated";
import { transferAssignment } from "./command/transferAssignment.generated";
import { updateAppointmentType } from "./command/updateAppointmentType.generated";
import { updateEmploymentType } from "./command/updateEmploymentType.generated";
import { updateJobProfile } from "./command/updateJobProfile.generated";
import { updatePosition } from "./command/updatePosition.generated";
import { updateWorker } from "./command/updateWorker.generated";
import { updateWorkerEmployment } from "./command/updateWorkerEmployment.generated";
import { updateWorkRegime } from "./command/updateWorkRegime.generated";
import { updateWorkSchedule } from "./command/updateWorkSchedule.generated";
import { createAppointmentHistoryType } from "./db/appointmentHistory";
import { createAppointmentTypeType } from "./db/appointmentType";
import { createAssignmentType } from "./db/assignment";
import { createEmploymentTypeType } from "./db/employmentType";
import { createJobProfileType } from "./db/jobProfile";
import { createPositionType } from "./db/position";
import { createWorkerType } from "./db/worker";
import { createWorkerEmploymentType } from "./db/workerEmployment";
import { createWorkRegimeType } from "./db/workRegime";
import { createWorkScheduleType } from "./db/workSchedule";
import { getAppointment } from "./query/getAppointment.generated";
import { getAppointmentType } from "./query/getAppointmentType.generated";
import { getAppointmentTypeByKey } from "./query/getAppointmentTypeByKey.generated";
import { getAssignment } from "./query/getAssignment.generated";
import { getEmploymentType } from "./query/getEmploymentType.generated";
import { getEmploymentTypeByKey } from "./query/getEmploymentTypeByKey.generated";
import { getJobProfile } from "./query/getJobProfile.generated";
import { getPosition } from "./query/getPosition.generated";
import { getWorker } from "./query/getWorker.generated";
import { getWorkerByUser } from "./query/getWorkerByUser.generated";
import { getWorkerEmployment } from "./query/getWorkerEmployment.generated";
import { getWorkRegime } from "./query/getWorkRegime.generated";
import { getWorkRegimeByKey } from "./query/getWorkRegimeByKey.generated";
import { getWorkSchedule } from "./query/getWorkSchedule.generated";
import { getWorkScheduleAsOf } from "./query/getWorkScheduleAsOf.generated";
import { listActiveWorkerEmployments } from "./query/listActiveWorkerEmployments.generated";
import { listActiveWorkSchedules } from "./query/listActiveWorkSchedules.generated";
import { listAppointmentsByWorker } from "./query/listAppointmentsByWorker.generated";
import { listAppointmentTypes } from "./query/listAppointmentTypes.generated";
import { listAssignmentsAsOf } from "./query/listAssignmentsAsOf.generated";
import { listAssignmentsByPosition } from "./query/listAssignmentsByPosition.generated";
import { listAssignmentsByWorker } from "./query/listAssignmentsByWorker.generated";
import { listEmploymentTypes } from "./query/listEmploymentTypes.generated";
import { listJobProfiles } from "./query/listJobProfiles.generated";
import { listPositionsByDepartment } from "./query/listPositionsByDepartment.generated";
import { listUpcomingAppointments } from "./query/listUpcomingAppointments.generated";
import { listVacantPositions } from "./query/listVacantPositions.generated";
import { listWorkerEmploymentsByWorker } from "./query/listWorkerEmploymentsByWorker.generated";
import { listWorkers } from "./query/listWorkers.generated";
import { listWorkRegimes } from "./query/listWorkRegimes.generated";
import { listWorkSchedulesByAssignment } from "./query/listWorkSchedulesByAssignment.generated";

type OrganizationModule = ReturnType<typeof defineOrganizationModule>;
type OrganizationDB = OrganizationModule["db"];
export type OrganizationQueries = OrganizationModule["queries"];

type UserManagementModule = ReturnType<typeof defineUserManagementModule>;
type UserManagementDB = UserManagementModule["db"];

export interface DefineModuleParams<
  WF extends Record<string, TailorAnyDBField> = EmptyFields,
  JF extends Record<string, TailorAnyDBField> = EmptyFields,
  WEF extends Record<string, TailorAnyDBField> = EmptyFields,
  AHF extends Record<string, TailorAnyDBField> = EmptyFields,
  WSF extends Record<string, TailorAnyDBField> = EmptyFields,
> {
  worker?: { fields?: WF };
  jobProfile?: { fields?: JF };
  workerEmployment?: { fields?: WEF };
  appointmentHistory?: { fields?: AHF };
  workSchedule?: { fields?: WSF };
  userManagement: {
    db: { user: UserManagementDB["user"] };
  };
  organization: {
    db: {
      company: OrganizationDB["company"];
      department: OrganizationDB["department"];
      site: OrganizationDB["site"];
    };
    queries: Pick<OrganizationQueries, "getCompany" | "getDepartment" | "getSite">;
  };
}

/* @__NO_SIDE_EFFECTS__ */
export const defineModule = <
  const WF extends Record<string, TailorAnyDBField> = EmptyFields,
  const JF extends Record<string, TailorAnyDBField> = EmptyFields,
  const WEF extends Record<string, TailorAnyDBField> = EmptyFields,
  const AHF extends Record<string, TailorAnyDBField> = EmptyFields,
  const WSF extends Record<string, TailorAnyDBField> = EmptyFields,
>(
  params: DefineModuleParams<WF, JF, WEF, AHF, WSF>,
) => {
  const worker = createWorkerType({
    ...params.worker,
    userType: params.userManagement.db.user,
  });
  const jobProfile = createJobProfileType({ ...params.jobProfile });
  const position = createPositionType({
    departmentType: params.organization.db.department,
    siteType: params.organization.db.site,
  });
  const workerEmployment = createWorkerEmploymentType({
    ...params.workerEmployment,
    companyType: params.organization.db.company,
  });
  const assignment = createAssignmentType();
  const appointmentHistory = createAppointmentHistoryType({ ...params.appointmentHistory });
  const appointmentType = createAppointmentTypeType({
    companyType: params.organization.db.company,
  });
  const employmentType = createEmploymentTypeType({ companyType: params.organization.db.company });
  const workRegime = createWorkRegimeType({ companyType: params.organization.db.company });
  const workSchedule = createWorkScheduleType({ ...params.workSchedule });

  const organizationQueries = params.organization.queries;

  return {
    db: {
      worker,
      jobProfile,
      position,
      workerEmployment,
      assignment,
      appointmentHistory,
      appointmentType,
      employmentType,
      workRegime,
      workSchedule,
    },
    commands: {
      createWorker: createWorker(),
      updateWorker: updateWorker(),
      createJobProfile: createJobProfile<TailorDBInsertable<JF>>(),
      // TODO: updateJobProfile's run() doesn't yet support custom fields (CF) — see commands.md rule.
      updateJobProfile: updateJobProfile(),
      deleteJobProfile: deleteJobProfile(),
      createPosition: createPosition(organizationQueries),
      updatePosition: updatePosition(organizationQueries),
      abolishPosition: abolishPosition(),
      createWorkerEmployment: createWorkerEmployment<TailorDBInsertable<WEF>>(organizationQueries),
      updateWorkerEmployment: updateWorkerEmployment<TailorDBInsertable<WEF>>(),
      terminateWorkerEmployment: terminateWorkerEmployment(),
      createAssignment: createAssignment(),
      transferAssignment: transferAssignment(),
      endAssignment: endAssignment(),
      recordAppointment: recordAppointment(),
      applyDueAppointments: applyDueAppointments(),
      createAppointmentType: createAppointmentType(),
      updateAppointmentType: updateAppointmentType(),
      deactivateAppointmentType: deactivateAppointmentType(),
      reactivateAppointmentType: reactivateAppointmentType(),
      createEmploymentType: createEmploymentType(),
      updateEmploymentType: updateEmploymentType(),
      deactivateEmploymentType: deactivateEmploymentType(),
      reactivateEmploymentType: reactivateEmploymentType(),
      createWorkRegime: createWorkRegime(),
      updateWorkRegime: updateWorkRegime(),
      deactivateWorkRegime: deactivateWorkRegime(),
      reactivateWorkRegime: reactivateWorkRegime(),
      createWorkSchedule: createWorkSchedule<TailorDBInsertable<WSF>>(),
      updateWorkSchedule: updateWorkSchedule<TailorDBInsertable<WSF>>(),
      endWorkSchedule: endWorkSchedule(),
    },
    queries: {
      getWorker,
      getWorkerByUser,
      listWorkers,
      getJobProfile,
      listJobProfiles,
      getPosition,
      listVacantPositions,
      listPositionsByDepartment,
      getWorkerEmployment,
      listActiveWorkerEmployments,
      listWorkerEmploymentsByWorker,
      getAssignment,
      listAssignmentsByWorker,
      listAssignmentsByPosition,
      listAssignmentsAsOf,
      getAppointment,
      listAppointmentsByWorker,
      listUpcomingAppointments,
      getAppointmentType,
      getAppointmentTypeByKey,
      listAppointmentTypes,
      getEmploymentType,
      getEmploymentTypeByKey,
      listEmploymentTypes,
      getWorkRegime,
      getWorkRegimeByKey,
      listWorkRegimes,
      getWorkSchedule,
      getWorkScheduleAsOf,
      listWorkSchedulesByAssignment,
      listActiveWorkSchedules,
    },
  };
};

/** EmptyFields-instantiated alias — use instead of `ReturnType<typeof defineModule>`, which widens field generics to their constraint. */
export type WorkforceModule = ReturnType<
  typeof defineModule<EmptyFields, EmptyFields, EmptyFields, EmptyFields, EmptyFields>
>;