"use client";

import { useEffect, useMemo, useState } from "react";
import { ProjectTaskTable, getDefaultProjectTaskRows, type TaskRow } from "@/components/project-task-table";
import { chiffrageTaskRowsByProject } from "@/lib/chiffrage-imports";
import { exportedProjects, exportedTaskRowsByProject } from "@/lib/project-export-imports";

type Project = {
  id: string;
  name: string;
  client: string;
  quoteNumber?: string;
};

type Planning = {
  projectId: string;
  team: Array<{ name: string; role: string; weekly: number[] }>;
};

const importedTaskRowsByProject = chiffrageTaskRowsByProject as Record<string, TaskRow[]>;
const exportedRowsByProject = exportedTaskRowsByProject as Record<string, TaskRow[]>;
const exportedProjectList = exportedProjects as Array<Project>;

export function ProjectDetailWorkspace({ projects, planning }: { projects: Project[]; planning: Planning[] }) {
  const initialRowsByProject = useMemo(() => {
    const rowsByProject: Record<string, TaskRow[]> = {};

    for (const project of projects) {
      rowsByProject[project.id] = getImportedRowsForProject(project);
    }

    return rowsByProject;
  }, [projects]);
  const [rowsByProject, setRowsByProject] = useState<Record<string, TaskRow[]>>(initialRowsByProject);
  const projectIds = useMemo(() => projects.map((project) => project.id), [projects]);
  const teamsByProject = useMemo(
    () =>
      Object.fromEntries(
        planning.map((item) => [
          item.projectId,
          item.team.map((member) => ({ name: member.name, role: member.role }))
        ])
      ),
    [planning]
  );

  useEffect(() => {
    let isActive = true;

    async function loadSavedRows() {
      if (projectIds.length === 0) {
        return;
      }

      try {
        const response = await fetch(`/api/project-task-rows?projectIds=${encodeURIComponent(projectIds.join(","))}`);

        if (!response.ok) {
          return;
        }

        const data = (await response.json()) as { rowsByProject?: Record<string, TaskRow[]> };

        if (isActive && data.rowsByProject) {
          setRowsByProject((current) => ({ ...current, ...data.rowsByProject }));
        }
      } catch {
        // La fiche reste lisible avec les donnees importees si la base locale n'est pas disponible.
      }
    }

    void loadSavedRows();

    return () => {
      isActive = false;
    };
  }, [projectIds]);

  function handleProjectRowsChange(projectId: string, rows: TaskRow[]) {
    setRowsByProject((current) => ({ ...current, [projectId]: rows }));
    void saveProjectRows(projectId, rows);
  }

  return (
    <ProjectTaskTable
      projects={projects}
      teamsByProject={teamsByProject}
      rowsByProject={rowsByProject}
      onProjectRowsChange={handleProjectRowsChange}
    />
  );
}

function getImportedRowsForProject(project: Project) {
  if (importedTaskRowsByProject[project.id]) {
    return importedTaskRowsByProject[project.id];
  }

  if (exportedRowsByProject[project.id]) {
    return exportedRowsByProject[project.id];
  }

  const exportedProject = exportedProjectList.find((candidate) => candidate.quoteNumber && candidate.quoteNumber === project.quoteNumber);

  if (exportedProject && exportedRowsByProject[exportedProject.id]) {
    return exportedRowsByProject[exportedProject.id];
  }

  return getDefaultProjectTaskRows();
}

async function saveProjectRows(projectId: string, rows: TaskRow[]) {
  try {
    await fetch("/api/project-task-rows", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ projectId, rows })
    });
  } catch {
    // L'interface reste utilisable meme si l'enregistrement local echoue ponctuellement.
  }
}