import { createBaselineEvaluation } from "@/lib/types";
import { ScenarioDefinitionSchema } from "@/lib/schemas";
import {
  formatScenarioDurationLabel,
  getScenarioTensionColor,
} from "@/lib/scenario-utils";
import type {
  CompanyMembership,
  FinalAssessment,
  ScenarioCatalogItem,
  ScenarioDefinition,
  SessionOverview,
  SessionRecord,
} from "@/lib/types";

type JsonValue = Record<string, unknown> | Array<unknown> | null;

export type TrainingSessionRow = {
  id: string;
  company_id: string;
  client_id: string | null;
  company_member_id: string;
  user_id: string;
  scenario_id: string;
  scenario_slug: string | null;
  scenario_template_id: string | null;
  scenario_version_id: string | null;
  scenario_title: string;
  scenario_target_skill: string;
  scenario_snapshot: JsonValue;
  status: SessionRecord["status"];
  transcript: JsonValue;
  live_evaluations: JsonValue;
  final_assessment: FinalAssessment | null;
  created_at: string;
  updated_at: string;
  completed_at: string | null;
  user_turns: number;
};

export function createInitialSession(
  scenario: ScenarioDefinition,
  sessionId: string,
  metadata?: {
    clientId?: string | null;
    scenarioTemplateId?: string | null;
    scenarioVersionId?: string | null;
  },
): SessionRecord {
  const now = new Date().toISOString();

  return {
    sessionId,
    clientId: metadata?.clientId ?? null,
    scenarioId: scenario.id,
    scenarioTemplateId: metadata?.scenarioTemplateId ?? null,
    scenarioVersionId: metadata?.scenarioVersionId ?? null,
    status: "ongoing",
    transcript: [
      {
        id: `${sessionId}-assistant-0`,
        role: "assistant",
        content: scenario.openingMessage,
        createdAt: now,
      },
    ],
    liveEvaluations: [createBaselineEvaluation(scenario)],
    finalAssessment: null,
    createdAt: now,
    updatedAt: now,
    userTurns: 0,
  };
}

export function toTrainingSessionInsert(
  session: SessionRecord,
  scenario: ScenarioCatalogItem,
  membership: CompanyMembership,
  userId: string,
) {
  return {
    id: session.sessionId,
    company_id: membership.companyId,
    client_id: membership.clientId,
    company_member_id: membership.id,
    user_id: userId,
    scenario_id: scenario.id,
    scenario_slug: scenario.id,
    scenario_template_id: scenario.templateId,
    scenario_version_id: scenario.versionId,
    scenario_title: scenario.title,
    scenario_target_skill: scenario.targetSkill,
    scenario_snapshot: {
      id: scenario.id,
      title: scenario.title,
      targetSkill: scenario.targetSkill,
      difficulty: scenario.difficulty,
      durationLabel: scenario.durationLabel,
      shortBrief: scenario.shortBrief,
      employeeProfile: scenario.employeeProfile,
      openingMessage: scenario.openingMessage,
      managerGoal: scenario.managerGoal,
      successSignals: scenario.successSignals,
      failureSignals: scenario.failureSignals,
      completionRules: scenario.completionRules,
      metricWeights: scenario.metricWeights,
      maxTurns: scenario.maxTurns,
      tensionColor: scenario.tensionColor,
    },
    status: session.status,
    transcript: session.transcript,
    live_evaluations: session.liveEvaluations,
    final_assessment: session.finalAssessment,
    user_turns: session.userTurns,
  };
}

export function readScenarioSnapshot(row: TrainingSessionRow) {
  const scenario = ScenarioDefinitionSchema.parse(
    row.scenario_snapshot ?? {
      id: row.scenario_slug ?? row.scenario_id,
      title: row.scenario_title,
      targetSkill: row.scenario_target_skill,
      difficulty: "Fondamentaux",
      durationLabel: "",
      shortBrief: "",
      employeeProfile: {
        name: "",
        role: "",
        team: "",
        seniority: "",
        currentMood: "",
      },
      openingMessage: "",
      managerGoal: "Cadre de session indisponible.",
      successSignals: ["Retrouver le contexte initial de la session."],
      failureSignals: ["Perdre le contexte initial de la session."],
      completionRules: ["Clore la session avec les informations disponibles."],
      metricWeights: {
        empathy: 1,
        clarity: 1,
        questioning: 1,
        deescalation: 1,
        accountability: 1,
        action_alignment: 1,
      },
      maxTurns: 8,
      tensionColor: "#1775BA",
    },
  );

  return {
    ...scenario,
    durationLabel: formatScenarioDurationLabel(scenario.maxTurns),
    tensionColor: getScenarioTensionColor(scenario.difficulty),
  };
}

export function mapTrainingSessionRow(row: TrainingSessionRow): SessionRecord {
  return {
    sessionId: row.id,
    clientId: row.client_id,
    scenarioId: row.scenario_slug ?? row.scenario_id,
    scenarioTemplateId: row.scenario_template_id,
    scenarioVersionId: row.scenario_version_id,
    status: row.status,
    transcript: Array.isArray(row.transcript)
      ? (row.transcript as SessionRecord["transcript"])
      : [],
    liveEvaluations: Array.isArray(row.live_evaluations)
      ? (row.live_evaluations as SessionRecord["liveEvaluations"])
      : [],
    finalAssessment: row.final_assessment,
    createdAt: row.created_at,
    updatedAt: row.updated_at,
    userTurns: row.user_turns,
  };
}

export function mapSessionOverview(row: TrainingSessionRow): SessionOverview {
  return {
    sessionId: row.id,
    clientId: row.client_id,
    scenarioId: row.scenario_slug ?? row.scenario_id,
    scenarioTemplateId: row.scenario_template_id,
    scenarioTitle: row.scenario_title,
    scenarioTargetSkill: row.scenario_target_skill,
    status: row.status,
    createdAt: row.created_at,
    updatedAt: row.updated_at,
    userTurns: row.user_turns,
    hasFinalAssessment: row.final_assessment !== null,
  };
}