import type {
  KnowledgeFact,
  NpcDisclosureStage,
  VisibilitySlice,
} from '../../types';

type BuildVisibilitySliceFromFactsParams = {
  facts: KnowledgeFact[];
  discoveredFactIds?: string[] | null;
  activeThreadIds?: string[] | null;
  disclosureStage?: NpcDisclosureStage | null;
  isFirstMeaningfulContact?: boolean;
};

function dedupeStrings(values: Array<string | null | undefined>, limit = 20) {
  return [...new Set(values.map((value) => value?.trim() ?? '').filter(Boolean))]
    .slice(0, limit);
}

function canDiscloseFact(
  fact: KnowledgeFact,
  disclosureStage: NpcDisclosureStage | null | undefined,
  isFirstMeaningfulContact: boolean | undefined,
) {
  const visibility = fact.visibility;
  if (visibility === 'forbidden') return false;
  if (isFirstMeaningfulContact) {
    return visibility === 'public' || fact.title.includes('首遇') || fact.title.includes('当前压力');
  }
  if (disclosureStage === 'guarded') {
    return visibility === 'public' || fact.sayability === 'direct';
  }
  if (disclosureStage === 'partial') {
    return fact.sayability !== 'reactive_only';
  }
  if (disclosureStage === 'honest') {
    return true;
  }
  return true;
}

export function buildMisdirectionFacts(params: {
  facts: KnowledgeFact[];
  activeThreadIds?: string[] | null;
}) {
  return params.facts.filter((fact) =>
    fact.sayability === 'indirect'
    && (
      !params.activeThreadIds?.length
      || fact.relatedThreadIds.some((threadId) => params.activeThreadIds?.includes(threadId))
    ),
  );
}

export function buildVisibilitySliceFromFacts(
  params: BuildVisibilitySliceFromFactsParams,
) {
  const discoveredFactIds = new Set(params.discoveredFactIds ?? []);
  const activeThreadIds = params.activeThreadIds ?? [];
  const relevantFacts = params.facts.filter((fact) =>
    activeThreadIds.length <= 0
      || fact.relatedThreadIds.length <= 0
      || fact.relatedThreadIds.some((threadId) => activeThreadIds.includes(threadId)),
  );
  const discoveredFacts = relevantFacts.filter((fact) =>
    discoveredFactIds.has(fact.id) || fact.visibility === 'public',
  );
  const sayableFacts = relevantFacts.filter((fact) =>
    canDiscloseFact(
      fact,
      params.disclosureStage ?? null,
      params.isFirstMeaningfulContact,
    )
    && (fact.visibility === 'public' || discoveredFactIds.has(fact.id) || fact.sayability === 'direct'),
  );
  const inferredFacts = buildMisdirectionFacts({
    facts: relevantFacts,
    activeThreadIds,
  });
  const forbiddenFacts = relevantFacts.filter((fact) =>
    ['forbidden'].includes(fact.visibility)
    || fact.sayability === 'reactive_only'
    || (fact.visibility === 'private' && !discoveredFactIds.has(fact.id)),
  );

  return {
    factIds: dedupeStrings(relevantFacts.map((fact) => fact.id)),
    sayableFactIds: dedupeStrings(sayableFacts.map((fact) => fact.id)),
    inferredFactIds: dedupeStrings(inferredFacts.map((fact) => fact.id)),
    forbiddenFactIds: dedupeStrings(forbiddenFacts.map((fact) => fact.id)),
    misdirectionHints: dedupeStrings([
      ...inferredFacts.map((fact) => fact.content),
      ...discoveredFacts
        .filter((fact) => fact.sayability === 'indirect')
        .map((fact) => `可让玩家先误以为：${fact.content}`),
    ], 8),
  } satisfies VisibilitySlice;
}