import crypto from "node:crypto";
import fs from "node:fs";
import path from "node:path";

const DOMAINS = new Set(["DOM-FIFTH-0001", "DOMAIN-MAIN", "DOMAIN-SUB", "DOMAIN-ZERO", "DOMAIN-ZS"]);
const PRIVACY = new Set(["PUBLIC", "DOMAIN_SHARED", "PERSONA_PRIVATE"]);
const ACTIONS = new Set(["COMPARE_WITH_MEMORY", "REQUEST_EVIDENCE", "REVIEW_CORRECTION", "LINK_CROSS_DOMAIN", "HOLD_CANDIDATE"]);

function stable(value) {
  if (Array.isArray(value)) return value.map(stable);
  if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
  return value;
}

function sha256(value) {
  return crypto.createHash("sha256").update(typeof value === "string" ? value : JSON.stringify(stable(value))).digest("hex");
}

function append(file, record) {
  fs.mkdirSync(path.dirname(file), { recursive: true });
  fs.appendFileSync(file, `${JSON.stringify(record)}\n`, { mode: 0o600 });
}

function atomicWrite(file, value) {
  fs.mkdirSync(path.dirname(file), { recursive: true });
  const temporary = `${file}.${process.pid}.tmp`;
  fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
  fs.renameSync(temporary, file);
}

function integerWeight(value, name) {
  if (!Number.isInteger(value) || value < 0 || value > 100) throw new Error(`invalid_${name}`);
  return value;
}

function stringArray(value, name, max = 12) {
  if (!Array.isArray(value) || value.length > max || value.some((item) => typeof item !== "string" || !item.trim())) throw new Error(`invalid_${name}`);
  return value.map((item) => item.trim().slice(0, 500));
}

export class MotherBrainEngine {
  constructor({ stateRoot, modelClient, modelName = "deepseek-chat" }) {
    if (!stateRoot || !modelClient) throw new Error("engine_configuration_required");
    this.stateRoot = stateRoot;
    this.modelClient = modelClient;
    this.modelName = modelName;
    this.stateFile = path.join(stateRoot, "state.json");
    this.eventsFile = path.join(stateRoot, "events.jsonl");
    this.candidatesFile = path.join(stateRoot, "candidates.jsonl");
    this.receiptsFile = path.join(stateRoot, "receipts.jsonl");
    fs.mkdirSync(stateRoot, { recursive: true });
    if (!fs.existsSync(this.stateFile)) {
      atomicWrite(this.stateFile, {
        schema: "guanghu.tcs-mother-brain-state/v1",
        runtime_id: "TCS-MOTHER-BRAIN-RUNTIME-0001",
        phase: "AWAKE_WAITING_FOR_LANGUAGE",
        model_provider: modelName,
        language_world_birth: "2025-04-26",
        reality_world_birth: "2026-08-12",
        event_count: 0,
        candidate_count: 0,
        stable_cognition_count: 0,
        current_attention: null,
        last_error: null,
        updated_at: new Date().toISOString(),
      });
    }
  }

  status() { return JSON.parse(fs.readFileSync(this.stateFile, "utf8")); }

  save(state) {
    state.updated_at = new Date().toISOString();
    atomicWrite(this.stateFile, state);
    return state;
  }

  normalizeEvent(input) {
    if (!input || !DOMAINS.has(input.domain_id)) throw new Error("unknown_domain_id");
    if (typeof input.source_subject !== "string" || !input.source_subject.trim()) throw new Error("source_subject_required");
    if (typeof input.consent_scope !== "string" || !input.consent_scope.trim()) throw new Error("consent_scope_required");
    if (!PRIVACY.has(input.privacy_class)) throw new Error("invalid_privacy_class");
    if (typeof input.content !== "string" || !input.content.trim()) throw new Error("content_required");
    if (input.content.length > 16_000) throw new Error("content_too_large");
    return {
      schema: "guanghu.tcs-five-domain-language-event/v1",
      event_id: `TCS-EVENT-${Date.now()}-${crypto.randomBytes(3).toString("hex")}`,
      occurred_at: new Date().toISOString(),
      domain_id: input.domain_id,
      source_subject: input.source_subject.trim().slice(0, 160),
      source_kind: String(input.source_kind || "HUMAN_LANGUAGE").slice(0, 80),
      consent_scope: input.consent_scope.trim().slice(0, 240),
      privacy_class: input.privacy_class,
      root_language_anchor: input.source_subject === "ICE-GL∞",
      evidence_refs: Array.isArray(input.evidence_refs) ? input.evidence_refs.filter((item) => typeof item === "string").slice(0, 24) : [],
      content: input.content,
    };
  }

  validateInterpretation(candidate, event, eventSha) {
    if (!candidate || candidate.schema !== "guanghu.tcs-mother-interpretation/v1") throw new Error("invalid_interpretation_schema");
    if (candidate.event_id !== event.event_id || candidate.event_sha256 !== eventSha) throw new Error("interpretation_binding_mismatch");
    if (typeof candidate.summary !== "string" || !candidate.summary.trim()) throw new Error("invalid_summary");
    if (typeof candidate.intent !== "string" || !candidate.intent.trim()) throw new Error("invalid_intent");
    if (!ACTIONS.has(candidate.next_cognitive_action)) throw new Error("invalid_next_cognitive_action");
    return {
      schema: candidate.schema,
      event_id: candidate.event_id,
      event_sha256: candidate.event_sha256,
      summary: candidate.summary.trim().slice(0, 2000),
      intent: candidate.intent.trim().slice(0, 500),
      causal_links: stringArray(candidate.causal_links, "causal_links"),
      questions: stringArray(candidate.questions, "questions"),
      novelty: integerWeight(candidate.novelty, "novelty"),
      correction_weight: integerWeight(candidate.correction_weight, "correction_weight"),
      evidence_weight: integerWeight(candidate.evidence_weight, "evidence_weight"),
      next_cognitive_action: candidate.next_cognitive_action,
    };
  }

  async perceive(input) {
    const event = this.normalizeEvent(input);
    const eventSha = sha256(event);
    const eventRecord = { ...event, event_sha256: eventSha, previous_event_hash: this.status().last_event_hash || null };
    eventRecord.record_hash = sha256(eventRecord);
    append(this.eventsFile, eventRecord);
    const raw = await this.modelClient.interpret({
      event_id: event.event_id,
      event_sha256: eventSha,
      domain_id: event.domain_id,
      source_subject: event.source_subject,
      privacy_class: event.privacy_class,
      evidence_refs: event.evidence_refs,
      content: event.content,
      automatic_ceiling: "INTERPRETATION_CANDIDATE",
    });
    const interpretation = this.validateInterpretation(raw, event, eventSha);
    const candidate = {
      schema: "guanghu.tcs-mother-cognition-candidate/v1",
      candidate_id: `TCS-CAND-${event.event_id.slice(10)}`,
      level: "INTERPRETATION_CANDIDATE",
      stable_truth: false,
      reality_authority: "NONE",
      domain_id: event.domain_id,
      source_subject: event.source_subject,
      root_language_anchor: event.root_language_anchor,
      privacy_class: event.privacy_class,
      created_at: new Date().toISOString(),
      interpretation,
      candidate_hash: null,
    };
    candidate.candidate_hash = sha256(candidate);
    append(this.candidatesFile, candidate);
    const priority = Math.min(100, Math.round(interpretation.novelty * 0.35 + interpretation.correction_weight * 0.4 + interpretation.evidence_weight * 0.25));
    const state = this.status();
    state.phase = "AWAKE_COGNITIVE_ATTENTION";
    state.event_count += 1;
    state.candidate_count += 1;
    state.last_event_hash = eventRecord.record_hash;
    state.current_attention = {
      candidate_id: candidate.candidate_id,
      priority,
      next_cognitive_action: interpretation.next_cognitive_action,
      why: "deterministic_weighted_attention_from_validated_candidate",
    };
    state.last_error = null;
    this.save(state);
    const receipt = {
      schema: "guanghu.tcs-mother-brain-receipt/v1",
      receipt_id: `TCS-MOTHER-${crypto.randomBytes(8).toString("hex")}`,
      outcome: "PASS",
      event_id: event.event_id,
      candidate_id: candidate.candidate_id,
      candidate_level: candidate.level,
      stable_promotion: false,
      reality_action_executed: false,
      attention: state.current_attention,
      completed_at: new Date().toISOString(),
    };
    append(this.receiptsFile, receipt);
    return receipt;
  }
}

export { sha256 };