import * as XLSX from "xlsx";
import type { Db } from "./db.ts";
import { callCoreFn, RpcCallError } from "./rpc.ts";
import { listBudget } from "./budget.ts";
import {
  exportWorkProgramWorkbook,
  matchWorkProgramImport,
  parseWorkProgramWorkbook,
  type WorkProgramExcelPreview,
} from "./work_program_excel.ts";

export type WorkProgramSummary = {
  program: Record<string, unknown> | null;
  periods: Record<string, unknown>[];
  budget_subtotal: number;
  curve: { period_index: number; label: string; amount: number; pct_period: number; pct_cumulative: number }[];
};

async function rpc<T>(db: Db, fn: string, payload: Record<string, unknown>): Promise<T> {
  const env = await callCoreFn(db, fn, payload);
  if (!env.ok) throw new RpcCallError(env);
  return env.data as T;
}

export async function getWorkProgram(db: Db, projectId: number): Promise<WorkProgramSummary> {
  return rpc(db, "core.fn_work_program_get", { project_id: projectId });
}

export async function listConcepts(db: Db, projectId: number) {
  return rpc<{ periods: Record<string, unknown>[]; items: Record<string, unknown>[] }>(
    db,
    "core.fn_work_program_list_concepts",
    { project_id: projectId },
  );
}

export async function listPartidas(db: Db, projectId: number) {
  return rpc<{ periods: Record<string, unknown>[]; chapters: Record<string, unknown>[] }>(
    db,
    "core.fn_work_program_list_partidas",
    { project_id: projectId },
  );
}

export async function getVsCost(db: Db, projectId: number) {
  return rpc(db, "core.fn_work_program_vs_cost", { project_id: projectId });
}

export async function previewWorkProgramExcel(
  bytes: Uint8Array,
  projectId: number,
  db: Db,
): Promise<WorkProgramExcelPreview & { match?: ReturnType<typeof matchWorkProgramImport> }> {
  const parsed = parseWorkProgramWorkbook(bytes);
  if (parsed.format === "none") return parsed;

  const budget = await listBudget(db, projectId);
  const ctx = {
    items: budget.items.map((i) => ({
      id: i.id,
      code: i.code,
      description: i.description,
      unit: i.unit,
      amount: Number(i.amount),
      chapter_id: i.chapter_id,
    })),
    chapters: budget.chapters.map((c) => ({
      id: c.id,
      code: c.code,
      name: c.name,
      amount: budget.items.filter((i) => i.chapter_id === c.id).reduce((s, i) => s + Number(i.amount), 0),
    })),
  };

  const matched = matchWorkProgramImport(parsed, ctx);
  return { ...matched.preview, match: matched };
}

export async function importWorkProgramExcel(
  db: Db,
  projectId: number,
  bytes: Uint8Array,
  opts?: { createChapters?: boolean },
): Promise<Record<string, unknown>> {
  const parsed = parseWorkProgramWorkbook(bytes);
  const budget = await listBudget(db, projectId);
  let chapters = [...budget.chapters];

  const ctx = {
    items: budget.items.map((i) => ({
      id: i.id,
      code: i.code,
      description: i.description,
      unit: i.unit,
      amount: Number(i.amount),
      chapter_id: i.chapter_id,
    })),
    chapters: chapters.map((c) => ({
      id: c.id,
      code: c.code,
      name: c.name,
      amount: budget.items.filter((i) => i.chapter_id === c.id).reduce((s, i) => s + Number(i.amount), 0),
    })),
  };

  let { payload, preview } = matchWorkProgramImport(parsed, ctx);

  if (opts?.createChapters !== false && payload.chapters_to_create.length) {
    for (const ch of payload.chapters_to_create) {
      await callCoreFn(db, "core.fn_budget_chapter_create", {
        project_id: projectId,
        code: ch.code,
        name: ch.name,
        sort_order: ch.sort_order,
      });
    }
    const refreshed = await listBudget(db, projectId);
    chapters = refreshed.chapters;
    const chapterByCode = new Map(chapters.map((c) => [c.code.toUpperCase(), c]));
    for (const row of preview.partidas) {
      const ch = chapterByCode.get(row.code.toUpperCase());
      if (!ch) continue;
      row.amounts.forEach((amount, i) => {
        if (amount !== 0) {
          payload.partida_amounts.push({
            budget_chapter_id: ch.id,
            period_index: i + 1,
            amount,
          });
        }
      });
    }
  }

  return rpc(db, "core.fn_work_program_replace", {
    project_id: projectId,
    source: "import",
    status: "active",
    concept_slots: payload.concept_slots,
    partida_amounts: payload.partida_amounts,
    chapters_to_create: [],
  });
}

export async function createEmptyWorkProgram(db: Db, projectId: number) {
  return rpc(db, "core.fn_work_program_replace", {
    project_id: projectId,
    source: "manual",
    status: "draft",
    concept_slots: [],
    partida_amounts: [],
  });
}

export async function generateWorkProgram(
  db: Db,
  projectId: number,
  strategy: string,
) {
  return rpc(db, "core.fn_work_program_generate", { project_id: projectId, strategy });
}

export async function updateConceptSlot(
  db: Db,
  projectId: number,
  budgetItemId: number,
  periodId: number,
  start_pct: number,
  end_pct: number,
) {
  return rpc(db, "core.fn_work_program_update_concept", {
    project_id: projectId,
    budget_item_id: budgetItemId,
    period_id: periodId,
    start_pct,
    end_pct,
  });
}

export async function updatePartidaAmount(
  db: Db,
  projectId: number,
  chapterId: number,
  periodId: number,
  amount: number,
) {
  return rpc(db, "core.fn_work_program_update_partida", {
    project_id: projectId,
    budget_chapter_id: chapterId,
    period_id: periodId,
    amount,
  });
}

export async function updateProgress(
  db: Db,
  projectId: number,
  budgetItemId: number,
  periodId: number,
  pct_complete: number,
) {
  return rpc(db, "core.fn_work_program_update_progress", {
    project_id: projectId,
    budget_item_id: budgetItemId,
    period_id: periodId,
    pct_complete,
  });
}

export async function recalculatePartidas(db: Db, projectId: number) {
  return rpc(db, "core.fn_work_program_recalculate_partidas", { project_id: projectId });
}

export async function exportWorkProgram(
  db: Db,
  projectId: number,
  kind: "concepto" | "partida",
  projectName: string,
): Promise<Uint8Array> {
  const summary = await getWorkProgram(db, projectId);
  const periodCount = summary.periods.length || 1;

  if (kind === "concepto") {
    const data = await listConcepts(db, projectId);
    const items = (data.items || []).map((item) => ({
      code: String(item.code || ""),
      description: String(item.description || ""),
      unit: String(item.unit || ""),
      periods: ((item.periods as { period_index: number; start_pct: number; end_pct: number }[]) || []).filter(
        (p) => Number(p.start_pct) !== 0 || Number(p.end_pct) !== 0,
      ),
    }));
    return exportWorkProgramWorkbook(kind, projectName, items, [], periodCount);
  }

  const data = await listPartidas(db, projectId);
  const chapters = (data.chapters || []).map((ch) => ({
    code: String(ch.code || ""),
    name: String(ch.name || ""),
    periods: ((ch.periods as { period_index: number; amount: number }[]) || []).filter((p) => Number(p.amount) !== 0),
  }));
  return exportWorkProgramWorkbook(kind, projectName, [], chapters, periodCount);
}

export { parseBarString } from "./work_program_excel.ts";