import { createHash } from 'node:crypto';
import type Database from 'better-sqlite3';
import type { AttributionConfidence } from './conversation-event-repository.js';
import {
  LearningTurnSchema,
  type LearningCreditClass,
  type LearningDecisionRecord,
  type LearningDecisionStatus,
  type LearningStage,
  type LearningTrajectoryDetail,
  type LearningTrajectoryRecord,
  type LearningTrajectoryStatus,
  type LearningTurn,
  type RetrievedLearningExample,
} from '../services/conversation-learning-types.js';
import type { ConversationPolicyMode } from '../services/conversation-state.js';

export interface UpsertLearningTrajectory {
  id: string;
  conversationId: string;
  sentMessageId: number | null;
  subreddit: string | null;
  sourceType: 'image' | 'chat' | null;
  policyMode: ConversationPolicyMode | null;
  firstHumanEventId: string | null;
  outcomeEventId: string;
  outcomeType: 'image-received' | 'reciprocal-engagement';
  creditClass: LearningCreditClass;
  attributionConfidence: AttributionConfidence;
  status: LearningTrajectoryStatus;
  maturityAt: number;
  invalidatedAt?: number | null;
  invalidationReason?: string | null;
  now?: number;
}

export interface UpsertLearningDecision {
  id: string;
  trajectoryId: string;
  decisionEventId: string;
  stage: LearningStage;
  context: LearningTurn[];
  chosenResponse: string;
  turnsUntilOutcome: number;
  isDirectMediaInvitation: boolean;
  qualityStatus: LearningDecisionStatus;
  now?: number;
}

export interface LearningSummary {
  total: number;
  provisional: number;
  eligible: number;
  excluded: number;
  invalidated: number;
  needsReview: number;
  humanCreated: number;
  humanImproved: number;
  humanCompletedAi: number;
  autonomous: number;
  recipientInitiated: number;
  uncertain: number;
  exact: number;
  fingerprint: number;
  inferred: number;
}

/** Persistence for derived, revocable learning trajectories and decisions. */
export class ConversationLearningRepository {
  constructor(
    private readonly db: Database.Database,
    private readonly accountId?: string,
  ) {}

  upsertTrajectory(input: UpsertLearningTrajectory): LearningTrajectoryRecord {
    const accountId = this.requireAccountId();
    const now = input.now ?? Date.now();
    this.db.prepare(`
      INSERT INTO conversation_learning_trajectories (
        id, account_id, conversation_id, sent_message_id, subreddit, source_type,
        policy_mode, first_human_event_id, outcome_event_id, outcome_type,
        credit_class, attribution_confidence, status, maturity_at,
        invalidated_at, invalidation_reason, created_at, updated_at
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(account_id, conversation_id, outcome_event_id) DO UPDATE SET
        sent_message_id = excluded.sent_message_id,
        subreddit = excluded.subreddit,
        source_type = excluded.source_type,
        policy_mode = excluded.policy_mode,
        first_human_event_id = excluded.first_human_event_id,
        credit_class = excluded.credit_class,
        attribution_confidence = excluded.attribution_confidence,
        status = CASE
          WHEN conversation_learning_trajectories.status = 'excluded' AND excluded.status != 'invalidated'
            THEN 'excluded'
          WHEN conversation_learning_trajectories.reviewed_at IS NOT NULL
            AND conversation_learning_trajectories.status = 'eligible'
            AND excluded.status != 'invalidated'
            THEN 'eligible'
          ELSE excluded.status
        END,
        maturity_at = excluded.maturity_at,
        invalidated_at = excluded.invalidated_at,
        invalidation_reason = excluded.invalidation_reason,
        updated_at = excluded.updated_at
    `).run(
      input.id, accountId, input.conversationId, input.sentMessageId,
      input.subreddit, input.sourceType, input.policyMode, input.firstHumanEventId,
      input.outcomeEventId, input.outcomeType, input.creditClass,
      input.attributionConfidence, input.status, input.maturityAt,
      input.invalidatedAt ?? null, input.invalidationReason ?? null, now, now,
    );
    if (input.sentMessageId !== null && input.outcomeType === 'image-received') {
      this.db.prepare(`
        UPDATE sent_messages
        SET image_outcome_credit = ?, image_outcome_at = ?
        WHERE account_id = ? AND id = ?
      `).run(input.creditClass, now, accountId, input.sentMessageId);
    }
    return this.getTrajectory(input.id)!;
  }

  replaceDecisions(trajectoryId: string, decisions: readonly UpsertLearningDecision[]): void {
    const accountId = this.requireAccountId();
    this.db.transaction(() => {
      const keep = new Set(decisions.map((decision) => decision.id));
      const existing = this.db.prepare(`
        SELECT id FROM conversation_learning_decisions
        WHERE account_id = ? AND trajectory_id = ?
      `).all(accountId, trajectoryId) as Array<{ id: string }>;
      for (const row of existing) {
        if (!keep.has(row.id)) {
          this.db.prepare('DELETE FROM conversation_learning_decisions WHERE account_id = ? AND id = ?')
            .run(accountId, row.id);
        }
      }
      for (const decision of decisions) this.upsertDecision(decision);
    })();
  }

  upsertDecision(input: UpsertLearningDecision): LearningDecisionRecord {
    const accountId = this.requireAccountId();
    const now = input.now ?? Date.now();
    this.db.prepare(`
      INSERT INTO conversation_learning_decisions (
        id, trajectory_id, account_id, decision_event_id, stage, context_json,
        chosen_response, turns_until_outcome, is_direct_media_invitation,
        quality_status, created_at, updated_at
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(trajectory_id, decision_event_id) DO UPDATE SET
        stage = excluded.stage,
        context_json = excluded.context_json,
        chosen_response = excluded.chosen_response,
        turns_until_outcome = excluded.turns_until_outcome,
        is_direct_media_invitation = excluded.is_direct_media_invitation,
        quality_status = CASE
          WHEN conversation_learning_decisions.quality_status = 'excluded' AND excluded.quality_status != 'invalidated'
            THEN 'excluded'
          WHEN EXISTS (
            SELECT 1 FROM conversation_learning_trajectories t
            WHERE t.id = excluded.trajectory_id AND t.reviewed_at IS NOT NULL AND t.status = 'eligible'
          ) AND excluded.quality_status != 'invalidated'
            THEN 'eligible'
          ELSE excluded.quality_status
        END,
        updated_at = excluded.updated_at
    `).run(
      input.id, input.trajectoryId, accountId, input.decisionEventId, input.stage,
      JSON.stringify(input.context), input.chosenResponse, input.turnsUntilOutcome,
      input.isDirectMediaInvitation ? 1 : 0, input.qualityStatus, now, now,
    );
    return this.getDecision(input.id)!;
  }

  getTrajectory(id: string): LearningTrajectoryDetail | undefined {
    const where = this.accountId ? 'id = ? AND account_id = ?' : 'id = ?';
    const params = this.accountId ? [id, this.accountId] : [id];
    const row = this.db.prepare(`SELECT * FROM conversation_learning_trajectories WHERE ${where}`)
      .get(...params) as TrajectoryRow | undefined;
    if (!row) return undefined;
    const decisions = (this.db.prepare(`
      SELECT * FROM conversation_learning_decisions
      WHERE trajectory_id = ? ORDER BY created_at ASC, id ASC
    `).all(id) as DecisionRow[]).map(mapDecision);
    return { ...mapTrajectory(row), decisions };
  }

  getDecision(id: string): LearningDecisionRecord | undefined {
    const where = this.accountId ? 'id = ? AND account_id = ?' : 'id = ?';
    const params = this.accountId ? [id, this.accountId] : [id];
    const row = this.db.prepare(`SELECT * FROM conversation_learning_decisions WHERE ${where}`)
      .get(...params) as DecisionRow | undefined;
    return row ? mapDecision(row) : undefined;
  }

  listTrajectories(input: { status?: LearningTrajectoryStatus; limit?: number } = {}): LearningTrajectoryRecord[] {
    const clauses: string[] = [];
    const params: Array<string | number> = [];
    if (this.accountId) {
      clauses.push('account_id = ?');
      params.push(this.accountId);
    }
    if (input.status) {
      clauses.push('status = ?');
      params.push(input.status);
    }
    params.push(Math.min(500, Math.max(1, input.limit ?? 100)));
    return (this.db.prepare(`
      SELECT * FROM conversation_learning_trajectories
      ${clauses.length ? `WHERE ${clauses.join(' AND ')}` : ''}
      ORDER BY updated_at DESC, id DESC LIMIT ?
    `).all(...params) as TrajectoryRow[]).map(mapTrajectory);
  }

  promoteMature(now = Date.now()): number {
    const accountClause = this.accountId ? 'AND account_id = ?' : '';
    const params = this.accountId ? [now, now, this.accountId] : [now, now];
    return this.db.prepare(`
      UPDATE conversation_learning_trajectories
      SET status = 'eligible', updated_at = ?
      WHERE status = 'provisional' AND maturity_at <= ? ${accountClause}
    `).run(...params).changes;
  }

  setReviewStatus(id: string, status: 'eligible' | 'excluded', now = Date.now()): boolean {
    const accountClause = this.accountId ? 'AND account_id = ?' : '';
    const params = this.accountId ? [status, now, now, id, this.accountId] : [status, now, now, id];
    const changed = this.db.prepare(`
      UPDATE conversation_learning_trajectories
      SET status = ?, reviewed_at = ?, updated_at = ?, invalidated_at = NULL, invalidation_reason = NULL
      WHERE id = ? ${accountClause} AND status != 'invalidated'
    `).run(...params).changes > 0;
    if (changed) {
      this.db.prepare(`
        UPDATE conversation_learning_decisions
        SET quality_status = ?, updated_at = ? WHERE trajectory_id = ?
      `).run(status, now, id);
    }
    return changed;
  }

  invalidateBySentMessageId(sentMessageId: number, reason: string, now = Date.now()): number {
    const accountId = this.requireAccountId();
    const rows = this.db.prepare(`
      SELECT id FROM conversation_learning_trajectories
      WHERE account_id = ? AND sent_message_id = ? AND status != 'invalidated'
    `).all(accountId, sentMessageId) as Array<{ id: string }>;
    if (rows.length === 0) return 0;
    this.db.transaction(() => {
      this.db.prepare(`
        UPDATE conversation_learning_trajectories
        SET status = 'invalidated', invalidated_at = ?, invalidation_reason = ?, updated_at = ?
        WHERE account_id = ? AND sent_message_id = ?
      `).run(now, reason.slice(0, 500), now, accountId, sentMessageId);
      for (const row of rows) {
        this.db.prepare(`
          UPDATE conversation_learning_decisions
          SET quality_status = 'invalidated', updated_at = ? WHERE trajectory_id = ?
        `).run(now, row.id);
      }
    })();
    return rows.length;
  }

  getEligibleExamples(input: {
    conversationId: string;
    policyMode: ConversationPolicyMode;
    stage: LearningStage;
    subreddit: string | null;
    minimumConfidence: AttributionConfidence;
    humanLimit: number;
    autonomousLimit: number;
    totalLimit: number;
  }): RetrievedLearningExample[] {
    const accountId = this.requireAccountId();
    const confidenceRank: Record<AttributionConfidence, number> = { inferred: 1, fingerprint: 2, exact: 3 };
    const minimumRank = confidenceRank[input.minimumConfidence];
    const rows = this.db.prepare(`
      SELECT d.*, t.credit_class, t.subreddit, t.policy_mode, t.attribution_confidence
      FROM conversation_learning_decisions d
      JOIN conversation_learning_trajectories t ON t.id = d.trajectory_id
      WHERE d.account_id = ? AND d.quality_status = 'eligible' AND t.status = 'eligible'
        AND t.conversation_id != ?
        AND (t.policy_mode = ? OR t.policy_mode IS NULL)
        AND (d.stage = ? OR d.stage = 'unknown')
      ORDER BY
        CASE WHEN t.subreddit = ? THEN 0 ELSE 1 END,
        CASE t.attribution_confidence WHEN 'exact' THEN 0 WHEN 'fingerprint' THEN 1 ELSE 2 END,
        t.updated_at DESC,
        d.updated_at DESC
      LIMIT 200
    `).all(accountId, input.conversationId, input.policyMode, input.stage, input.subreddit) as RetrievalRow[];
    const eligible = rows.filter((row) => confidenceRank[row.attribution_confidence] >= minimumRank);
    const human = eligible.filter((row) => row.credit_class.startsWith('human-')).slice(0, input.humanLimit);
    const autonomous = eligible.filter((row) =>
      row.credit_class === 'autonomous-success' || row.credit_class === 'recipient-initiated-media')
      .slice(0, input.autonomousLimit);
    return [...human, ...autonomous].slice(0, input.totalLimit).map(mapRetrieval);
  }

  recordGeneration(input: {
    conversationId: string;
    incomingEventId: string;
    purpose: 'reply' | 'media-ask';
    mode: 'shadow' | 'injected';
    policyVersion: string;
    exampleIds: readonly string[];
    promptSha256?: string | null;
    generatedAt?: number;
  }): void {
    const accountId = this.requireAccountId();
    this.db.prepare(`
      INSERT INTO learning_generation_context (
        account_id, conversation_id, incoming_event_id, purpose, mode,
        policy_version, example_ids_json, prompt_sha256, generated_at
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(account_id, conversation_id, incoming_event_id, purpose, policy_version, mode)
      DO UPDATE SET example_ids_json = excluded.example_ids_json,
        prompt_sha256 = excluded.prompt_sha256, generated_at = excluded.generated_at
    `).run(
      accountId, input.conversationId, input.incomingEventId, input.purpose, input.mode,
      input.policyVersion, JSON.stringify(input.exampleIds), input.promptSha256 ?? null,
      input.generatedAt ?? Date.now(),
    );
  }

  getSummary(): LearningSummary {
    const accountClause = this.accountId ? 'WHERE account_id = ?' : '';
    const params = this.accountId ? [this.accountId] : [];
    const row = this.db.prepare(`
      SELECT COUNT(*) AS total,
        SUM(status = 'provisional') AS provisional,
        SUM(status = 'eligible') AS eligible,
        SUM(status = 'excluded') AS excluded,
        SUM(status = 'invalidated') AS invalidated,
        SUM(status = 'needs-review') AS needs_review,
        SUM(credit_class = 'human-created-success') AS human_created,
        SUM(credit_class = 'human-improved-success') AS human_improved,
        SUM(credit_class = 'human-completed-ai-trajectory') AS human_completed_ai,
        SUM(credit_class = 'autonomous-success') AS autonomous,
        SUM(credit_class = 'recipient-initiated-media') AS recipient_initiated,
        SUM(credit_class = 'uncertain') AS uncertain,
        SUM(attribution_confidence = 'exact') AS exact,
        SUM(attribution_confidence = 'fingerprint') AS fingerprint,
        SUM(attribution_confidence = 'inferred') AS inferred
      FROM conversation_learning_trajectories ${accountClause}
    `).get(...params) as Record<string, number | null>;
    return {
      total: row.total ?? 0,
      provisional: row.provisional ?? 0,
      eligible: row.eligible ?? 0,
      excluded: row.excluded ?? 0,
      invalidated: row.invalidated ?? 0,
      needsReview: row.needs_review ?? 0,
      humanCreated: row.human_created ?? 0,
      humanImproved: row.human_improved ?? 0,
      humanCompletedAi: row.human_completed_ai ?? 0,
      autonomous: row.autonomous ?? 0,
      recipientInitiated: row.recipient_initiated ?? 0,
      uncertain: row.uncertain ?? 0,
      exact: row.exact ?? 0,
      fingerprint: row.fingerprint ?? 0,
      inferred: row.inferred ?? 0,
    };
  }

  listEvaluationRuns(limit = 20): LearningEvaluationRun[] {
    return (this.db.prepare(`
      SELECT * FROM learning_evaluation_runs ORDER BY created_at DESC LIMIT ?
    `).all(Math.min(100, Math.max(1, limit))) as EvaluationRow[]).map((row) => ({
      id: row.id,
      policyVersion: row.policy_version,
      datasetVersion: row.dataset_version,
      baselinePolicyVersion: row.baseline_policy_version,
      status: row.status,
      totalCases: row.total_cases,
      hardGateFailures: row.hard_gate_failures,
      summary: parseObject(row.summary_json),
      createdAt: row.created_at,
      completedAt: row.completed_at,
    }));
  }

  saveEvaluationRun(run: LearningEvaluationRun): void {
    this.db.prepare(`
      INSERT INTO learning_evaluation_runs (
        id, policy_version, dataset_version, baseline_policy_version, status,
        total_cases, hard_gate_failures, summary_json, created_at, completed_at
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(id) DO UPDATE SET status = excluded.status,
        total_cases = excluded.total_cases,
        hard_gate_failures = excluded.hard_gate_failures,
        summary_json = excluded.summary_json,
        completed_at = excluded.completed_at
    `).run(
      run.id, run.policyVersion, run.datasetVersion, run.baselinePolicyVersion,
      run.status, run.totalCases, run.hardGateFailures, JSON.stringify(run.summary),
      run.createdAt, run.completedAt,
    );
  }

  private requireAccountId(): string {
    if (!this.accountId) throw new Error('An account ID is required for this learning operation');
    return this.accountId;
  }
}

export interface LearningEvaluationRun {
  id: string;
  policyVersion: string;
  datasetVersion: string;
  baselinePolicyVersion: string | null;
  status: 'running' | 'passed' | 'failed';
  totalCases: number;
  hardGateFailures: number;
  summary: Record<string, unknown>;
  createdAt: number;
  completedAt: number | null;
}

interface TrajectoryRow {
  id: string;
  account_id: string;
  conversation_id: string;
  sent_message_id: number | null;
  subreddit: string | null;
  source_type: 'image' | 'chat' | null;
  policy_mode: ConversationPolicyMode | null;
  first_human_event_id: string | null;
  outcome_event_id: string;
  outcome_type: 'image-received' | 'reciprocal-engagement';
  credit_class: LearningCreditClass;
  attribution_confidence: AttributionConfidence;
  status: LearningTrajectoryStatus;
  maturity_at: number;
  invalidated_at: number | null;
  invalidation_reason: string | null;
  reviewed_at: number | null;
  created_at: number;
  updated_at: number;
}

interface DecisionRow {
  id: string;
  trajectory_id: string;
  account_id: string;
  decision_event_id: string;
  stage: LearningStage;
  context_json: string;
  chosen_response: string;
  turns_until_outcome: number;
  is_direct_media_invitation: number;
  quality_status: LearningDecisionStatus;
  created_at: number;
  updated_at: number;
}

interface RetrievalRow extends DecisionRow {
  credit_class: LearningCreditClass;
  subreddit: string | null;
  policy_mode: ConversationPolicyMode | null;
  attribution_confidence: AttributionConfidence;
}

interface EvaluationRow {
  id: string;
  policy_version: string;
  dataset_version: string;
  baseline_policy_version: string | null;
  status: 'running' | 'passed' | 'failed';
  total_cases: number;
  hard_gate_failures: number;
  summary_json: string;
  created_at: number;
  completed_at: number | null;
}

function mapTrajectory(row: TrajectoryRow): LearningTrajectoryRecord {
  return {
    id: row.id,
    accountId: row.account_id,
    conversationId: row.conversation_id,
    sentMessageId: row.sent_message_id,
    subreddit: row.subreddit,
    sourceType: row.source_type,
    policyMode: row.policy_mode,
    firstHumanEventId: row.first_human_event_id,
    outcomeEventId: row.outcome_event_id,
    outcomeType: row.outcome_type,
    creditClass: row.credit_class,
    attributionConfidence: row.attribution_confidence,
    status: row.status,
    maturityAt: row.maturity_at,
    invalidatedAt: row.invalidated_at,
    invalidationReason: row.invalidation_reason,
    reviewedAt: row.reviewed_at,
    createdAt: row.created_at,
    updatedAt: row.updated_at,
  };
}

function mapDecision(row: DecisionRow): LearningDecisionRecord {
  const parsed = LearningTurnSchema.array().safeParse(parseJson(row.context_json));
  return {
    id: row.id,
    trajectoryId: row.trajectory_id,
    accountId: row.account_id,
    decisionEventId: row.decision_event_id,
    stage: row.stage,
    context: parsed.success ? parsed.data : [],
    chosenResponse: row.chosen_response,
    turnsUntilOutcome: row.turns_until_outcome,
    isDirectMediaInvitation: Boolean(row.is_direct_media_invitation),
    qualityStatus: row.quality_status,
    createdAt: row.created_at,
    updatedAt: row.updated_at,
  };
}

function mapRetrieval(row: RetrievalRow): RetrievedLearningExample {
  const decision = mapDecision(row);
  return {
    decisionId: decision.id,
    trajectoryId: decision.trajectoryId,
    creditClass: row.credit_class,
    stage: decision.stage,
    context: decision.context,
    chosenResponse: decision.chosenResponse,
    turnsUntilOutcome: decision.turnsUntilOutcome,
    subreddit: row.subreddit,
    policyMode: row.policy_mode,
  };
}

function parseJson(value: string): unknown {
  try { return JSON.parse(value) as unknown; }
  catch { return null; }
}

function parseObject(value: string): Record<string, unknown> {
  const parsed = parseJson(value);
  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
    ? parsed as Record<string, unknown>
    : {};
}

export function stableLearningId(...parts: readonly string[]): string {
  return createHash('sha256').update(parts.join('\u0000')).digest('hex').slice(0, 32);
}