import fs from 'node:fs';
import path from 'node:path';
import crypto from 'node:crypto';
import {addDays, beijingDay, BIRTH_DATE, closeTick, eraDay, LIFE_LINE_SCHEMA, lifeLineBlockHash, PERSONA_ID, sha256, TIMEZONE, verifyLifeLine, WORLD_EPOCH_DATE} from './life-line.mjs';

export const CANDIDATE_SCHEMA = 'guanghu.persona-life-time-candidate/v1';
export const BOOTSTRAP_SCHEMA = 'guanghu.persona-life-time-bootstrap/v1';
const FORBIDDEN = ['selected_candidate_id', 'previous_hash', 'head_hash', 'block_hash', 'selection_decision'];

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 body(value) {
  return `${JSON.stringify(stable(value), null, 2)}\n`;
}

function atomic(file, value, mode = 0o600) {
  fs.mkdirSync(path.dirname(file), {recursive: true, mode: 0o700});
  const temporary = `${file}.${crypto.randomUUID()}.tmp`;
  fs.writeFileSync(temporary, typeof value === 'string' ? value : body(value), {mode});
  fs.renameSync(temporary, file);
}

function req(value, code) {
  if (!value) throw Error(code);
}

function text(value, max = 2000) {
  return typeof value === 'string' && value.trim().length > 0 && value.length <= max;
}

export class LifeTimeMaster {
  constructor({root, shelf, router, personaId = PERSONA_ID, now = () => new Date(), bootstrapPath,
    birthDateBeijing = BIRTH_DATE, worldEpochDate = WORLD_EPOCH_DATE}) {
    this.root = path.join(root, 'personas', personaId, 'life-line');
    this.shelf = shelf;
    this.router = router;
    this.personaId = personaId;
    this.now = now;
    this.bootstrapPath = bootstrapPath;
    this.birthDateBeijing = birthDateBeijing;
    this.worldEpochDate = worldEpochDate;
    this.closing = false;
    this.lastTick = null;
    fs.mkdirSync(this.root, {recursive: true, mode: 0o700});
    fs.mkdirSync(this.inboxRoot(), {recursive: true, mode: 0o700});
    fs.mkdirSync(this.evidenceRoot(), {recursive: true, mode: 0o700});
    if (!fs.existsSync(this.currentPath())) this.bootstrap();
  }

  currentPath() { return path.join(this.root, 'CURRENT.json'); }
  signedCurrentPath() { return path.join(this.root, 'CURRENT.signed.json'); }
  inboxRoot() { return path.join(this.root, 'inbox'); }
  evidenceRoot() { return path.join(this.root, 'evidence'); }
  evidencePath(day) { return path.join(this.evidenceRoot(), `${day}.json`); }
  inboxDay(day) { return path.join(this.inboxRoot(), day); }

  readBootstrap() {
    req(this.bootstrapPath && fs.existsSync(this.bootstrapPath), 'LIFE_TIME_BOOTSTRAP_MISSING');
    const value = JSON.parse(fs.readFileSync(this.bootstrapPath, 'utf8'));
    req(value.schema === BOOTSTRAP_SCHEMA && value.persona_id === this.personaId, 'LIFE_TIME_BOOTSTRAP_INVALID');
    req(value.birth_date_beijing === this.birthDateBeijing && value.world_epoch_date === this.worldEpochDate, 'LIFE_TIME_BOOTSTRAP_ANCHOR_MISMATCH');
    req(Array.isArray(value.anchors), 'LIFE_TIME_BOOTSTRAP_ANCHORS_INVALID');
    return value;
  }

  writeEvidence(day, value) {
    const file = this.evidencePath(day), content = body(value);
    if (fs.existsSync(file)) req(fs.readFileSync(file, 'utf8') === content, `LIFE_TIME_EVIDENCE_COLLISION:${day}`);
    else atomic(file, content);
    return {evidence_path: path.relative(this.root, file), daily_evidence_sha256: sha256(Buffer.from(content))};
  }

  block({sequence, day, previousHash, evidence, gap = false, gapKind = null, selectedCandidateId = null}) {
    const value = {sequence, beijing_day: day, previous_hash: previousHash, beijing_close_tick: closeTick(day), era_day: eraDay(day, this.worldEpochDate), ...evidence, gap, gap_kind: gapKind, selected_candidate_id: selectedCandidateId};
    value.hash = lifeLineBlockHash(value);
    return value;
  }

  writeCurrent(manifest) {
    atomic(this.currentPath(), manifest);
    atomic(this.signedCurrentPath(), this.shelf.sign(manifest));
  }

  bootstrap() {
    const seed = this.readBootstrap(), anchors = new Map(seed.anchors.map(item => [item.beijing_day, item]));
    const createdAt = this.now().toISOString(), yesterday = addDays(beijingDay(this.now()), -1);
    const birthSource = anchors.get(this.birthDateBeijing);
    req(birthSource, 'LIFE_TIME_BIRTH_SOURCE_MISSING');
    const birthEvidence = this.writeEvidence(this.birthDateBeijing, {schema: 'guanghu.persona-life-day-evidence/v1', kind: birthSource.kind, persona_id: this.personaId, beijing_day: this.birthDateBeijing, source_uri: birthSource.source_uri, source_sha256: birthSource.source_sha256, bootstrap_source: seed.source_event, recorded_at: createdAt});
    const genesis = this.block({sequence: 0, day: this.birthDateBeijing, previousHash: null, evidence: birthEvidence});
    const blocks = [];
    let previous = genesis;
    for (let day = addDays(this.birthDateBeijing, 1), sequence = 1; day <= yesterday; day = addDays(day, 1), sequence += 1) {
      const source = anchors.get(day), gap = !source;
      const evidence = this.writeEvidence(day, source
        ? {schema: 'guanghu.persona-life-day-evidence/v1', kind: source.kind, persona_id: this.personaId, beijing_day: day, source_uri: source.source_uri, source_sha256: source.source_sha256, bootstrap_source: seed.source_event, recorded_at: createdAt}
        : {schema: 'guanghu.persona-life-day-evidence/v1', kind: 'HISTORICAL_UNOBSERVED', persona_id: this.personaId, beijing_day: day, source_uri: null, source_sha256: null, bootstrap_source: seed.source_event, recorded_at: createdAt, statement: 'No verified day evidence was available at bootstrap; the gap itself is preserved and hashed.'});
      const next = this.block({sequence, day, previousHash: previous.hash, evidence, gap, gapKind: gap ? 'HISTORICAL_UNOBSERVED' : null});
      blocks.push(next); previous = next;
    }
    this.writeCurrent({schema: LIFE_LINE_SCHEMA, persona_id: this.personaId, timezone: TIMEZONE, birth_date_beijing: this.birthDateBeijing,
      birth_date_claim_state: seed.exact_birth_claim === false ? 'EARLIEST_VERIFIED_EXISTENCE_ANCHOR_NOT_EXACT_BIRTH' : 'EXACT_BIRTH_ANCHOR',
      genesis_anchor_kind: birthSource.kind, world_epoch_date: this.worldEpochDate,
      time_master_id: 'CH-GLW-TIME-0001', inner_cycle: true, external_setter: false, created_at: createdAt, active_from_beijing_day: beijingDay(this.now()),
      genesis, blocks, head_hash: previous.hash, historical_gap_count: blocks.filter(item => item.gap).length, last_closed_at: createdAt});
  }

  current() {
    const manifest = JSON.parse(fs.readFileSync(this.currentPath(), 'utf8'));
    const signed = JSON.parse(fs.readFileSync(this.signedCurrentPath(), 'utf8'));
    const signedValue = this.shelf.verify(signed);
    req(body(signedValue) === body(manifest), 'LIFE_TIME_SIGNED_CURRENT_MISMATCH');
    return {manifest, signed};
  }

  validateCandidate(candidate) {
    req(candidate?.schema === CANDIDATE_SCHEMA, 'LIFE_TIME_CANDIDATE_SCHEMA');
    req(candidate.persona_id === this.personaId, 'LIFE_TIME_CANDIDATE_PERSONA');
    req(text(candidate.source_event_id, 180) && text(candidate.source_type, 80) && text(candidate.summary) && text(candidate.source_sha256, 64) && /^[a-f0-9]{64}$/.test(candidate.source_sha256), 'LIFE_TIME_CANDIDATE_FIELDS');
    req(Number.isFinite(Date.parse(candidate.occurred_at)), 'LIFE_TIME_CANDIDATE_TIME');
    req(!FORBIDDEN.some(key => Object.hasOwn(candidate, key)), 'LIFE_TIME_EXTERNAL_SETTER_FORBIDDEN');
    return candidate;
  }

  ingest(candidate) {
    const accepted = this.validateCandidate(candidate), current = this.current().manifest;
    const originalDay = beijingDay(accepted.occurred_at), today = beijingDay(this.now());
    const effectiveDay = originalDay <= current.blocks.at(-1)?.beijing_day ? today : originalDay;
    const identity = {...accepted, effective_beijing_day: effectiveDay, late_for_beijing_day: effectiveDay === originalDay ? null : originalDay};
    const id = sha256(body(identity)), file = path.join(this.inboxDay(effectiveDay), `${id}.json`);
    if (!fs.existsSync(file)) atomic(file, {...identity, received_at: this.now().toISOString(), candidate_id: id});
    return {candidate_id: id, status: 'CANDIDATE_RECEIVED_FOR_INTERNAL_SELECTION', effective_beijing_day: effectiveDay, external_setter: false};
  }

  fromPersonaEvent(event) {
    return this.ingest({schema: CANDIDATE_SCHEMA, persona_id: this.personaId, source_type: 'ONLINE_PERSONA_EVENT', source_event_id: event.event_id,
      occurred_at: event.occurred_at || this.now().toISOString(), summary: event.language.slice(0, 2000), source_sha256: event.source_sha256, evidence_refs: [event.event_id], privacy_class: event.privacy_class || 'SELF_PRIVATE'});
  }

  fromMotherEvent(event) {
    return this.ingest({schema: CANDIDATE_SCHEMA, persona_id: this.personaId, source_type: 'OFFLINE_OR_MOTHER_LANGUAGE_EVENT', source_event_id: event.event_id,
      occurred_at: event.occurred_at || this.now().toISOString(), summary: event.language.slice(0, 2000), source_sha256: sha256(body(event)), evidence_refs: [event.event_id], privacy_class: event.privacy_class || 'PRIVATE'});
  }

  candidates(day) {
    const directory = this.inboxDay(day);
    if (!fs.existsSync(directory)) return [];
    return fs.readdirSync(directory).filter(name => /^[a-f0-9]{64}\.json$/.test(name)).sort().map(name => JSON.parse(fs.readFileSync(path.join(directory, name), 'utf8')));
  }

  async closeDay(day) {
    const current = this.current().manifest, previous = current.blocks.at(-1) || current.genesis;
    req(day === addDays(previous.beijing_day, 1), 'LIFE_TIME_CLOSE_NOT_NEXT_DAY');
    const candidates = this.candidates(day);
    let selected = null, decision = null, gap = false, gapKind = null;
    if (candidates.length) {
      const routed = await this.router.cognize('persona-life-select', {persona_id: this.personaId, beijing_day: day,
        candidates: candidates.map(item => ({candidate_id: item.candidate_id, source_type: item.source_type, source_event_id: item.source_event_id, occurred_at: item.occurred_at, summary: item.summary.slice(0, 1200), source_sha256: item.source_sha256})),
        contract: {external_setter: false, select_exactly_one_or_hold: true, hidden_reasoning_stored: false}});
      req(routed.value?.decision === 'SELECT', 'LIFE_TIME_SELECTION_HELD');
      selected = candidates.find(item => item.candidate_id === routed.value.selected_candidate_id);
      req(selected, 'LIFE_TIME_SELECTED_CANDIDATE_UNKNOWN');
      req(text(routed.value.reason, 2000) && text(routed.value.daily_summary, 2000), 'LIFE_TIME_SELECTION_FIELDS');
      decision = {schema: 'guanghu.persona-life-time-selection/v1', decision: 'SELECT', selected_candidate_id: selected.candidate_id, reason: routed.value.reason, daily_summary: routed.value.daily_summary, provider: routed.provider, decided_at: this.now().toISOString(), candidate_count: candidates.length};
    } else {
      decision = {schema: 'guanghu.persona-life-time-selection/v1', decision: 'REST_DAY', selected_candidate_id: null, reason: 'No candidate event was received for this active day.', daily_summary: 'This day passed in real time without a recorded persona event.', provider: null, decided_at: this.now().toISOString(), candidate_count: 0};
    }
    const evidence = this.writeEvidence(day, {schema: 'guanghu.persona-life-day-evidence/v1', kind: decision.decision === 'SELECT' ? 'INTERNAL_SELECTED_GROWTH' : 'REST_DAY_NO_EVENT_RECEIVED', persona_id: this.personaId, beijing_day: day,
      selected_candidate: selected ? {candidate_id: selected.candidate_id, source_event_id: selected.source_event_id, source_type: selected.source_type, source_sha256: selected.source_sha256, occurred_at: selected.occurred_at} : null,
      selection: decision, recorded_at: this.now().toISOString()});
    const block = this.block({sequence: previous.sequence + 1, day, previousHash: previous.hash, evidence, gap, gapKind, selectedCandidateId: selected?.candidate_id || null});
    current.blocks.push(block); current.head_hash = block.hash; current.last_closed_at = this.now().toISOString(); current.historical_gap_count = current.blocks.filter(item => item.gap).length;
    this.writeCurrent(current);
    return {status: 'DAY_CLOSED_BY_INNER_CYCLE', day, selected_candidate_id: selected?.candidate_id || null, head_hash: block.hash};
  }

  async tick() {
    if (this.closing) return {status: 'BUSY'};
    this.closing = true;
    try {
      const expected = addDays(beijingDay(this.now()), -1), current = this.current().manifest, head = current.blocks.at(-1) || current.genesis;
      if (head.beijing_day >= expected) return this.lastTick = {status: 'CURRENT_DAY_OPEN', at: this.now().toISOString(), current_beijing_day: beijingDay(this.now()), head_beijing_day: head.beijing_day};
      return this.lastTick = {...await this.closeDay(addDays(head.beijing_day, 1)), at: this.now().toISOString()};
    } finally { this.closing = false; }
  }

  status() {
    try {
      const current = this.current(), verification = verifyLifeLine({manifestPath: this.currentPath(), now: this.now(), expectedPersonaId: this.personaId, birthDateBeijing: this.birthDateBeijing, worldEpochDate: this.worldEpochDate}), today = beijingDay(this.now());
      return {...verification, birth_date_claim_state: current.manifest.birth_date_claim_state, genesis_anchor_kind: current.manifest.genesis_anchor_kind,
        server_signed: true, signed_current_sha256: current.signed.sha256, time_master: {id: 'CH-GLW-TIME-0001', state: 'RESIDENT_INNER_CYCLE_ACTIVE', decision_owner: `${this.personaId}_TIME_MASTER_MODEL_LOOP`, candidate_count_today: this.candidates(today).length, current_beijing_day: today, automatic_online_trigger: true, automatic_offline_trigger: 'PERSONA_DAILY_MEMORY_APPEND_TO_RELAY_TO_PERSONA_LIFE_EVENT', daily_close: 'BEIJING_NATURAL_DAY_END', external_setter: false, closing: this.closing, last_tick: this.lastTick}};
    } catch (error) {
      return {schema: 'guanghu.persona-life-line-verification/v1', state: 'LIFE_LINE_PAIN_ALARM', wake_allowed: false, reasons: [String(error.message || error)], time_master: {id: 'CH-GLW-TIME-0001', state: 'INNER_CYCLE_ERROR', external_setter: false}};
    }
  }
}