import type { DraftField } from '../domain/draft';
import type { FieldConflict } from '../domain/conflict';
import type { FieldApplyResult, FillFieldValue, RepeatGroup, StepFillStructure } from '../domain/types';

import { defineStore } from 'pinia';

import { checkboxGroupTransition, checkboxGroupViolations } from '../domain/checkbox-group';
import { isReferenceTag } from '../domain/draft';
import { reconcileDocumentValue } from '../domain/conflict';
import { parseTag } from '../domain/tags';

function syncReferenceDrafts(fields: DraftField[], primaryTag: string, value: FillFieldValue) {
  const primary = parseTag(primaryTag);
  if (primary?.type !== 'single') return;
  const prefix = `eln.ref.${primary.fieldCode}.`;
  fields.filter((item) => item.tag.startsWith(prefix)).forEach((item) => {
    item.draftValue = value;
  });
}

export const useFillerStore = defineStore('filler', {
  state: () => ({
    status: 'initializing' as 'error' | 'initializing' | 'ready' | 'working',
    conflicts: {} as Record<string, FieldConflict>,
    checkboxGroupError: '',
    checkboxGroupNotice: '',
    fields: [] as DraftField[],
    fieldErrors: {} as Record<string, string>,
    formulaResultsStale: false,
    focusedTag: null as null | string,
    documentSyncError: '',
    repeatError: '',
    sourceSyncError: '',
    repeatGroups: [] as RepeatGroup[],
    stepStructure: undefined as StepFillStructure | undefined,
    currentStepId: null as null | string,
    message: '正在连接文档...',
  }),
  actions: {
    setStepStructure(structure?: StepFillStructure) {
      this.stepStructure = structure;
      const steps = [...(structure?.configuration.steps ?? [])].sort((left, right) => left.order - right.order);
      this.currentStepId = steps.some((step) => step.id === this.currentStepId)
        ? this.currentStepId
        : (steps[0]?.id ?? null);
    },
    selectStep(stepId: string) {
      if (this.stepStructure?.configuration.steps.some((step) => step.id === stepId)) {
        this.currentStepId = stepId;
      }
    },
    refreshCheckboxGroupError() {
      const violation = checkboxGroupViolations(this.fields, this.stepStructure)[0];
      if (!violation) this.checkboxGroupError = '';
      else if (violation.kind === 'invalid') {
        this.checkboxGroupError = `选择组“${violation.checkboxGroupCode}”数量规则无效`;
      } else if (violation.kind === 'minimum') {
        this.checkboxGroupError = `选择组“${violation.checkboxGroupCode}”至少选择 ${violation.minSelected} 项`;
      } else {
        this.checkboxGroupError = `选择组“${violation.checkboxGroupCode}”最多选择 ${violation.maxSelected} 项`;
      }
    },
    setDraft(tag: string, value: FillFieldValue) {
      if (isReferenceTag(tag)) return false;
      const field = this.fields.find((item) => item.tag === tag);
      if (!field || field.readOnly) return false;
      const transition = checkboxGroupTransition(this.fields, field, value, this.stepStructure);
      if (!transition.accepted) {
        this.checkboxGroupNotice = transition.message ?? '';
        return false;
      }
      this.checkboxGroupNotice = '';
      const changes = transition.changes;
      for (const change of changes) {
        const changedField = this.fields.find((item) => item.tag === change.tag);
        if (!changedField || changedField.readOnly || isReferenceTag(change.tag)) continue;
        if (changedField.draftValue !== change.value) this.formulaResultsStale = true;
        changedField.draftValue = change.value;
        const conflict = this.conflicts[change.tag];
        if (conflict) {
          const reconciliation = reconcileDocumentValue(conflict.baseValue, change.value, conflict.documentValue);
          if (reconciliation.conflict) this.conflicts[change.tag] = reconciliation.conflict;
          else delete this.conflicts[change.tag];
        }
        syncReferenceDrafts(this.fields, change.tag, change.value);
      }
      this.refreshCheckboxGroupError();
      return true;
    },
    syncDocumentField(tag: string, value: FillFieldValue) {
      const field = this.fields.find((item) => item.tag === tag);
      if (!field || (field.type === 'checkbox') !== (typeof value === 'boolean')) return;
      if (field.documentValue !== value) this.formulaResultsStale = true;
      if (isReferenceTag(tag)) {
        field.currentValue = value;
        field.documentValue = value;
        delete this.conflicts[tag];
        return;
      }
      const baseValue = this.conflicts[tag]?.baseValue ?? field.documentValue;
      const reconciliation = reconcileDocumentValue(baseValue, field.draftValue, value);
      field.currentValue = value;
      field.documentValue = reconciliation.documentValue;
      field.draftValue = reconciliation.draftValue;
      if (reconciliation.conflict) this.conflicts[tag] = reconciliation.conflict;
      else delete this.conflicts[tag];
      if (!reconciliation.conflict) syncReferenceDrafts(this.fields, tag, reconciliation.draftValue);
      this.refreshCheckboxGroupError();
    },
    resolveConflict(tag: string, resolution: 'document' | 'draft') {
      const field = this.fields.find((item) => item.tag === tag);
      const conflict = this.conflicts[tag];
      if (!field || !conflict) return;
      if (resolution === 'document') {
        field.draftValue = conflict.documentValue;
        syncReferenceDrafts(this.fields, tag, conflict.documentValue);
      }
      field.documentValue = conflict.documentValue;
      delete this.conflicts[tag];
      this.refreshCheckboxGroupError();
    },
    applyResults(results: FieldApplyResult[], options: { preserveExistingErrors?: boolean } = {}) {
      if (!options.preserveExistingErrors) this.fieldErrors = {};
      for (const result of results) {
        const field = this.fields.find((item) => item.tag === result.tag);
        if (!field) continue;
        delete this.fieldErrors[result.tag];
        if (result.ok) field.documentValue = field.draftValue;
        else this.fieldErrors[result.tag] = result.error || '应用失败';
      }
    },
  },
});