export const metricIds = [
  "empathy",
  "clarity",
  "questioning",
  "deescalation",
  "accountability",
  "action_alignment",
] as const;

export type MetricId = (typeof metricIds)[number];

export const metricMeta: Record<MetricId, { label: string }> = {
  empathy: { label: "Empathie" },
  clarity: { label: "Qualite de reformulation / clarte" },
  questioning: { label: "Pertinence du questionnement" },
  deescalation: { label: "Qualite d'ecoute" },
  accountability: { label: "Posture d'accompagnement" },
  action_alignment: { label: "Orientation solution / action" },
};

export type PlatformRole = "admin" | "learner";

export type MemberStatus = "pending" | "active" | "suspended";

export type Difficulty =
  | "Fondamentaux"
  | "Intermédiaire"
  | "Intermediaire"
  | "Exigeant";

export type CatalogStatus = "draft" | "published" | "archived";

export type ClientStatus = "active" | "archived";

export type TagStatus = "active" | "archived";

export type ConversationStatus =
  | "ongoing"
  | "resolved"
  | "escalated"
  | "max_turns"
  | "manual_end";

export type ConversationOutcome = Exclude<ConversationStatus, "ongoing">;

export type MetricLevel =
  | "Fragile"
  | "A consolider"
  | "Solide"
  | "Impact fort";

export type ChatMessage = {
  id: string;
  role: "assistant" | "user";
  content: string;
  createdAt: string;
};

export type RawMetric = {
  id: MetricId;
  score: number;
  rationale: string;
};

export type MetricResult = RawMetric & {
  level: MetricLevel;
};

export type LiveEvaluation = {
  metrics: MetricResult[];
  coachingNote: string;
  riskFlags: string[];
  learnerSignal: string;
};

export type FinalAssessment = {
  outcome: ConversationOutcome;
  summary: string;
  readiness: string;
  metricSummary: MetricResult[];
  strengths: string[];
  missedOpportunities: string[];
  turningPoints: string[];
  actionPlan: string[];
  closingAdvice: string;
};

export type CoachSourceKind = "knowledge" | "profile" | "report" | "system";

export type CoachMessageSource = {
  id: string;
  kind: CoachSourceKind;
  label: string;
  detail: string;
  similarity?: number | null;
  documentId?: string | null;
  chunkId?: string | null;
};

export type CoachConversationRecord = {
  id: string;
  title: string;
  messageCount: number;
  createdAt: string;
  updatedAt: string;
  lastMessageAt: string | null;
};

export type CoachMessageRecord = {
  id: string;
  conversationId: string;
  role: "assistant" | "user";
  content: string;
  createdAt: string;
  sources: CoachMessageSource[];
};

export type KnowledgeDocumentStatus = "processing" | "ready" | "failed";

export type KnowledgeDocumentRecord = {
  id: string;
  title: string;
  sourceLabel: string | null;
  fileName: string;
  contentType: string;
  fileSize: number;
  status: KnowledgeDocumentStatus;
  chunkCount: number;
  contentLength: number;
  errorMessage: string | null;
  createdAt: string;
  updatedAt: string;
};

export type KnowledgeChunkMatch = {
  chunkId: string;
  documentId: string;
  documentTitle: string;
  sourceLabel: string | null;
  chunkIndex: number;
  content: string;
  similarity: number;
  metadata: Record<string, unknown>;
};

export type KnowledgeAdminDashboardData = {
  documents: KnowledgeDocumentRecord[];
};

export type EmployeeProfile = {
  name: string;
  role: string;
  team: string;
  seniority: string;
  currentMood: string;
};

export type DemoAppConfig = {
  appName: string;
  loginTitle: string;
  loginDescription: string;
  demoUser: {
    email: string;
    fullName: string;
    companyLabel: string;
  };
  coach: {
    name: string;
  };
};

export type ScenarioDefinition = {
  id: string;
  title: string;
  targetSkill: string;
  difficulty: Difficulty;
  durationLabel: string;
  shortBrief: string;
  employeeProfile: EmployeeProfile;
  openingMessage: string;
  managerGoal: string;
  successSignals: string[];
  failureSignals: string[];
  completionRules: string[];
  metricWeights: Record<MetricId, number>;
  maxTurns: number;
  tensionColor: string;
};

export type DemoKnowledgeEntry = {
  id: string;
  title: string;
  sourceLabel: string | null;
  content: string;
  tags: string[];
};

export type TagRecord = {
  id: string;
  label: string;
  slug: string;
  status: TagStatus;
  scenarioCount: number;
  groupCount: number;
};

export type ClientRecord = {
  id: string;
  name: string;
  slug: string;
  status: ClientStatus;
  legacyCompanyId: string | null;
};

export type CompanyRecord = {
  id: string;
  name: string;
  slug: string;
  clientId: string | null;
};

export type ScenarioCatalogItem = ScenarioDefinition & {
  templateId: string;
  versionId: string;
  versionNumber: number;
  status: CatalogStatus;
  tags: TagRecord[];
};

export type ScenarioTemplateRecord = {
  id: string;
  slug: string;
  status: CatalogStatus;
  currentPublishedVersionId: string | null;
  currentDraftVersionId: string | null;
  publishedVersionNumber: number | null;
  draftVersionNumber: number | null;
  publishedScenario: ScenarioCatalogItem | null;
  draftScenario: ScenarioCatalogItem | null;
  tags: TagRecord[];
};

export type ScenarioGroupMemberRecord = {
  companyMemberId: string;
  email: string;
  fullName: string | null;
  role: PlatformRole;
  status: MemberStatus;
  magicLinkLastSentAt: string | null;
};

export type ScenarioGroupRecord = {
  id: string;
  name: string;
  slug: string;
  description: string | null;
  status: CatalogStatus;
  companyId: string | null;
  companyName: string | null;
  accessStartsAt: string | null;
  accessEndsAt: string | null;
  tags: TagRecord[];
  scenarioTemplateIds: string[];
  members: ScenarioGroupMemberRecord[];
  memberCount: number;
};

export type EffectiveAccessRecord = {
  clientId: string;
  scenarioTemplateId: string;
  scenarioSlug: string;
  scenarioTitle: string;
  source: "direct" | "group";
  groupId: string | null;
  groupName: string | null;
};

export type ClientAccessAssignment = {
  clientId: string;
  groupIds: string[];
  scenarioTemplateIds: string[];
};

export type AdminDashboardData = {
  companies: CompanyRecord[];
  clients: ClientRecord[];
  tags: TagRecord[];
  groups: ScenarioGroupRecord[];
  scenarios: ScenarioTemplateRecord[];
  effectiveAccess: EffectiveAccessRecord[];
  clientAssignments: ClientAccessAssignment[];
};

export type SessionRecord = {
  sessionId: string;
  clientId: string | null;
  scenarioId: string;
  scenarioTemplateId: string | null;
  scenarioVersionId: string | null;
  status: ConversationStatus;
  transcript: ChatMessage[];
  liveEvaluations: LiveEvaluation[];
  finalAssessment: FinalAssessment | null;
  createdAt: string;
  updatedAt: string;
  userTurns: number;
};

export type DemoSessionRecord = SessionRecord & {
  scenarioSnapshot: ScenarioDefinition;
};

export type CompanyMembership = {
  id: string;
  companyId: string;
  clientId: string;
  email: string;
  fullName: string | null;
  role: PlatformRole;
  status: MemberStatus;
  companyName: string | null;
  companySlug: string | null;
  clientName: string | null;
  clientSlug: string | null;
};

export type PlatformAdminRecord = {
  id: string;
  authUserId: string | null;
  email: string;
  fullName: string | null;
  status: MemberStatus;
};

export type SessionOverview = {
  sessionId: string;
  clientId: string | null;
  scenarioId: string;
  scenarioTemplateId: string | null;
  scenarioTitle: string;
  scenarioTargetSkill: string;
  status: ConversationStatus;
  createdAt: string;
  updatedAt: string;
  userTurns: number;
  hasFinalAssessment: boolean;
};

export type DemoRecentSessionContext = {
  scenarioTitle: string;
  scenarioTargetSkill: string;
  status: ConversationStatus;
  updatedAt: string;
  finalAssessment: Pick<
    FinalAssessment,
    "summary" | "readiness" | "actionPlan"
  > | null;
};

export type UserProgressOverview = {
  companyMemberId: string;
  totalSessions: number;
  completedSessions: number;
  resolvedSessions: number;
  escalatedSessions: number;
  latestActivityAt: string | null;
};

export type TurnRequest = {
  sessionId: string;
  userMessage: string;
};

export type TurnResponse = {
  assistantMessage: ChatMessage;
  liveEvaluation: LiveEvaluation;
  conversationStatus: {
    status: ConversationStatus;
    reason: string;
  };
};

export type FinalizeRequest = {
  sessionId: string;
  conversationStatus?: ConversationOutcome;
};

export type CreateCoachConversationRequest = {
  title?: string;
};

export type CreateCoachMessageRequest = {
  content: string;
};

export type CreateSessionRequest = {
  scenarioId: string;
};

export type SessionResponse = {
  session: SessionRecord;
};

export type MagicLinkRequest = {
  email: string;
};

export type DemoAccessRequest = {
  password: string;
  next?: string;
};

export type DemoTurnRequest = {
  sessionId: string;
  scenario: ScenarioDefinition;
  transcript: ChatMessage[];
  liveEvaluations: LiveEvaluation[];
  userTurns: number;
  status: ConversationStatus;
  userMessage: string;
};

export type DemoFinalizeRequest = {
  scenario: ScenarioDefinition;
  transcript: ChatMessage[];
  liveEvaluations: LiveEvaluation[];
  currentStatus: ConversationStatus;
  conversationStatus?: ConversationOutcome;
};

export type DemoCoachReplyRequest = {
  conversationId: string;
  history: CoachMessageRecord[];
  userMessage: string;
  onboardingPromptContext: string;
  actionPlanPrompt: string;
  recentSessions: DemoRecentSessionContext[];
};

export type DemoCoachConversationRecord = CoachConversationRecord & {
  messages: CoachMessageRecord[];
};

export type ScenarioMutationPayload = {
  templateId?: string;
  title: string;
  targetSkill: string;
  difficulty: Difficulty;
  shortBrief: string;
  employeeProfile: EmployeeProfile;
  openingMessage: string;
  managerGoal: string;
  successSignals: string[];
  failureSignals: string[];
  completionRules: string[];
  metricWeights: Record<MetricId, number>;
  maxTurns: number;
  tagIds: string[];
};

export function scoreToLevel(score: number): MetricLevel {
  if (score < 45) {
    return "Fragile";
  }

  if (score < 65) {
    return "A consolider";
  }

  if (score < 82) {
    return "Solide";
  }

  return "Impact fort";
}

export function hydrateMetrics(metrics: RawMetric[]): MetricResult[] {
  const byId = new Map(metrics.map((metric) => [metric.id, metric]));

  return metricIds.map((id) => {
    const metric = byId.get(id) ?? {
      id,
      score: 50,
      rationale:
        "Mesure non fournie par l'analyseur, positionnée à un niveau neutre.",
    };

    const score = Math.max(0, Math.min(100, Math.round(metric.score)));

    return {
      id,
      score,
      rationale: metric.rationale,
      level: scoreToLevel(score),
    };
  });
}

export function createBaselineEvaluation(
  scenario?: Pick<ScenarioDefinition, "managerGoal">,
): LiveEvaluation {
  return {
    metrics: metricIds.map((id) => ({
      id,
      score: 50,
      rationale:
        "La métrique se mettra à jour après votre première réponse managériale.",
      level: scoreToLevel(50),
    })),
    coachingNote: scenario
      ? `Commencez par sécuriser le cadre, reconnaître la perception du collaborateur et clarifier votre intention de manager : ${scenario.managerGoal}`
      : "Commencez par sécuriser le cadre et clarifier votre intention managériale.",
    riskFlags: [],
    learnerSignal:
      "Aucun signal évalué pour le moment : la première réponse servira de point de départ.",
  };
}

export function formatStatusLabel(status: ConversationStatus): string {
  switch (status) {
    case "ongoing":
      return "Simulation en cours";
    case "resolved":
      return "Situation désamorcée";
    case "escalated":
      return "Situation escaladée";
    case "max_turns":
      return "Fin de session par limite de tours";
    case "manual_end":
      return "Clôture manuelle";
    default:
      return "Statut inconnu";
  }
}