import type { SupabaseClient } from "@supabase/supabase-js";
import { deriveStatusAsOf, EVENT_DATE_OPEN, parseStatuses, todayIso, type OrgLookups, type ReportEmployee, type ReportEvent } from "./reports";
import { fetchAllRows } from "./supabase/query";
import type { Database, EmploymentType, HistoryEventType } from "./supabase/types";

// Shared by the Berichte page and /api/export/* so they can never drift on
// what "the current view" means — same filters, same stichtag/event-window
// rules.
export type ReportFilters = {
  division?: string;
  location?: string;
  status?: string;
  employment?: string;
};

export type SnapshotFilters = ReportFilters & { asOf?: string };
export type EventFilters = { eventType?: HistoryEventType; division?: string; location?: string; from?: string; to?: string };

export async function loadOrgLookups(supabase: SupabaseClient<Database>): Promise<{
  lookups: OrgLookups;
  divisions: { id: string; name: string }[];
  locations: { id: string; name: string }[];
}> {
  const [{ data: divisions }, { data: departments }, { data: teams }, { data: locations }] = await Promise.all([
    supabase.from("divisions").select("id, name").order("name"),
    supabase.from("departments").select("id, name"),
    supabase.from("teams").select("id, name, department_id"),
    supabase.from("locations").select("id, name").order("name"),
  ]);

  const departmentNameById = new Map((departments ?? []).map((d) => [d.id, d.name]));
  return {
    lookups: {
      divisionName: new Map((divisions ?? []).map((d) => [d.id, d.name])),
      departmentNameByTeam: new Map((teams ?? []).map((t) => [t.id, departmentNameById.get(t.department_id) ?? "Unbekannt"])),
      teamName: new Map((teams ?? []).map((t) => [t.id, t.name])),
      locationName: new Map((locations ?? []).map((l) => [l.id, l.name])),
    },
    divisions: divisions ?? [],
    locations: locations ?? [],
  };
}

const SNAPSHOT_EMPLOYEE_COLUMNS =
  "id, first_name, last_name, job_title, division_id, team_id, location_id, employment_type, contract_type, entry_date, exit_date, weekly_hours, source, paygrade, birth_date, gender, karenz_start_date, karenz_return_date, worker_type, collective_agreement, work_days, is_betriebsrat, has_dienstwagen, is_laterale_fuehrung, is_c_level";

// employee_id -> number of employee_dependents rows. Selects only the FK
// column (no dependent PII needed) since only per-employee counts feed the
// has_dependents/avg_dependents report dimensions; counted client-side
// since the Supabase JS client has no `count(*) group by employee_id`
// shorthand. Shared by the Bestand pivot and the full employees export.
export async function loadDependentsCounts(supabase: SupabaseClient<Database>): Promise<Map<string, number>> {
  const rows = await fetchAllRows(() => supabase.from("employee_dependents").select("employee_id").order("employee_id"));
  const counts = new Map<string, number>();
  for (const d of rows) counts.set(d.employee_id, (counts.get(d.employee_id) ?? 0) + 1);
  return counts;
}

// Bestand zum Stichtag: reconstructs each employee's status as of `asOf`
// (defaults to today) from entry/exit/Karenz dates — see deriveStatusAsOf.
// division/team/location still reflect the employee's *current* assignment.
export async function loadSnapshotEmployees(supabase: SupabaseClient<Database>, filters: SnapshotFilters): Promise<ReportEmployee[]> {
  const asOf = filters.asOf || todayIso();

  function snapshotQuery() {
    let query = supabase.from("employees").select(SNAPSHOT_EMPLOYEE_COLUMNS).order("id");
    if (filters.division) query = query.eq("division_id", filters.division);
    if (filters.location) query = query.eq("location_id", filters.location);
    if (filters.employment) query = query.eq("employment_type", filters.employment as EmploymentType);
    return query;
  }

  const [data, dependentsCounts] = await Promise.all([fetchAllRows(snapshotQuery), loadDependentsCounts(supabase)]);

  const withDerivedStatus: ReportEmployee[] = data.map((e) => ({
    id: e.id,
    first_name: e.first_name,
    last_name: e.last_name,
    job_title: e.job_title,
    division_id: e.division_id,
    team_id: e.team_id,
    location_id: e.location_id,
    status: deriveStatusAsOf(e, asOf),
    employment_type: e.employment_type,
    contract_type: e.contract_type,
    entry_date: e.entry_date,
    exit_date: e.exit_date,
    weekly_hours: e.weekly_hours,
    source: e.source,
    paygrade: e.paygrade,
    birth_date: e.birth_date,
    gender: e.gender,
    worker_type: e.worker_type,
    collective_agreement: e.collective_agreement,
    work_days: e.work_days,
    is_betriebsrat: e.is_betriebsrat,
    has_dienstwagen: e.has_dienstwagen,
    is_laterale_fuehrung: e.is_laterale_fuehrung,
    is_c_level: e.is_c_level,
    dependents_count: dependentsCounts.get(e.id) ?? 0,
  }));

  const statuses = parseStatuses(filters.status);
  return withDerivedStatus.filter((e) => statuses.includes(e.status as (typeof statuses)[number]));
}

// Ereignisse: employee_history has no division_id/team_id of its own, so
// this joins in the affected employee's *current* org placement (two plain
// queries, merged in JS — the hand-written Database type has no relational
// embedding metadata for a single nested-select query).
//
// from/to: "" (unset) falls back to the current calendar year; the literal
// sentinel EVENT_DATE_OPEN means that side of the interval is intentionally
// unbounded (e.g. "alle Ereignisse bis heute", no start date).
export async function loadEventHistory(supabase: SupabaseClient<Database>, filters: EventFilters): Promise<ReportEvent[]> {
  const currentYear = new Date().getFullYear();
  const from = filters.from === EVENT_DATE_OPEN ? undefined : filters.from || `${currentYear}-01-01`;
  const to = filters.to === EVENT_DATE_OPEN ? undefined : filters.to || `${currentYear}-12-31`;

  function historyQuery() {
    let query = supabase.from("employee_history").select("employee_id, event_date, event_type, description").order("id");
    if (from) query = query.gte("event_date", from);
    if (to) query = query.lte("event_date", to);
    if (filters.eventType) query = query.eq("event_type", filters.eventType);
    return query;
  }

  const [history, employees] = await Promise.all([
    fetchAllRows(historyQuery),
    fetchAllRows(() => supabase.from("employees").select("id, first_name, last_name, job_title, division_id, team_id, location_id").order("id")),
  ]);

  const employeeById = new Map(employees.map((e) => [e.id, e]));
  const events: ReportEvent[] = [];
  for (const h of history) {
    const emp = employeeById.get(h.employee_id);
    if (!emp) continue;
    if (filters.division && emp.division_id !== filters.division) continue;
    if (filters.location && emp.location_id !== filters.location) continue;
    events.push({
      employee_id: emp.id,
      first_name: emp.first_name,
      last_name: emp.last_name,
      job_title: emp.job_title,
      division_id: emp.division_id,
      team_id: emp.team_id,
      location_id: emp.location_id,
      event_date: h.event_date,
      event_type: h.event_type,
      description: h.description,
    });
  }
  return events;
}