import type { DraftField } from './draft';
import type { FillFieldValue, StepFillStructure } from './types';

import { parseTag } from './tags';

export interface CheckboxGroupViolation {
  checkboxGroupCode: string;
  fields: DraftField[];
  kind: 'invalid' | 'maximum' | 'minimum';
  maxSelected: null | number;
  minSelected: number;
  selectedCount: number;
}

export interface CheckboxGroupTransition {
  accepted: boolean;
  changes: Array<{ tag: string; value: FillFieldValue }>;
  message?: string;
}

export function checkboxGroupRuntimeIdentity(
  field: DraftField,
  structure?: StepFillStructure,
): string | undefined {
  if (field.type !== 'checkbox' || !field.checkboxGroupCode || field.readOnly) return undefined;
  const parsed = parseTag(field.tag);
  if (!parsed || parsed.type === 'reference') return undefined;
  if (parsed.type === 'repeat') {
    return `repeat:${parsed.groupCode}:${parsed.rowId}:${field.checkboxGroupCode}`;
  }
  const stepId = structure ? structure.controlSteps[field.tag] : '';
  return stepId === undefined ? undefined : `step:${stepId}:${field.checkboxGroupCode}`;
}

export function checkboxGroupDeselections(
  fields: DraftField[],
  target: DraftField,
  value: FillFieldValue,
  structure?: StepFillStructure,
): Array<{ tag: string; value: false }> {
  return checkboxGroupTransition(fields, target, value, structure).changes
    .filter((change): change is { tag: string; value: false } => change.tag !== target.tag && change.value === false);
}

export function checkboxGroupTransition(
  fields: DraftField[],
  target: DraftField,
  value: FillFieldValue,
  structure?: StepFillStructure,
): CheckboxGroupTransition {
  const targetChange = { tag: target.tag, value };
  if (target.type !== 'checkbox' || typeof value !== 'boolean') {
    return { accepted: true, changes: [targetChange] };
  }
  const identity = checkboxGroupRuntimeIdentity(target, structure);
  if (!identity || !target.checkboxGroupCode || value === false) {
    return { accepted: true, changes: [targetChange] };
  }
  const members = fields.filter((field) => checkboxGroupRuntimeIdentity(field, structure) === identity);
  const rule = checkboxGroupRule(members);
  if (!rule.valid) {
    return {
      accepted: false,
      changes: [],
      message: `选择组“${target.checkboxGroupCode}”数量规则无效`,
    };
  }
  const selectedPeers = members.filter((field) => field.tag !== target.tag && field.draftValue === true);
  if (rule.maxSelected === 1) {
    return {
      accepted: true,
      changes: [targetChange, ...selectedPeers.map((field) => ({ tag: field.tag, value: false as const }))],
    };
  }
  if (rule.maxSelected !== null && selectedPeers.length + 1 > rule.maxSelected) {
    return {
      accepted: false,
      changes: [],
      message: `选择组“${target.checkboxGroupCode}”最多选择 ${rule.maxSelected} 项`,
    };
  }
  return { accepted: true, changes: [targetChange] };
}

export function checkboxGroupViolations(
  fields: DraftField[],
  structure?: StepFillStructure,
): CheckboxGroupViolation[] {
  const groups = new Map<string, DraftField[]>();
  for (const field of fields) {
    const identity = checkboxGroupRuntimeIdentity(field, structure);
    if (!identity || !field.checkboxGroupCode) continue;
    groups.set(identity, [...(groups.get(identity) ?? []), field]);
  }
  const violations: CheckboxGroupViolation[] = [];
  for (const members of groups.values()) {
    const rule = checkboxGroupRule(members);
    const selected = members.filter((field) => field.draftValue === true);
    const common = {
      checkboxGroupCode: members[0]!.checkboxGroupCode!,
      fields: selected,
      maxSelected: rule.maxSelected,
      minSelected: rule.minSelected,
      selectedCount: selected.length,
    };
    if (!rule.valid) violations.push({ ...common, kind: 'invalid' });
    else if (selected.length < rule.minSelected) violations.push({ ...common, kind: 'minimum' });
    else if (rule.maxSelected !== null && selected.length > rule.maxSelected) {
      violations.push({ ...common, kind: 'maximum' });
    }
  }
  return violations;
}

function checkboxGroupRule(fields: DraftField[]): {
  maxSelected: null | number;
  minSelected: number;
  valid: boolean;
} {
  const first = fields[0];
  const minSelected = first?.checkboxGroupMinSelected ?? 0;
  const maxSelected = first?.checkboxGroupMaxSelected === undefined
    ? 1
    : first.checkboxGroupMaxSelected;
  const validRange = Number.isInteger(minSelected) && minSelected >= 0
    && (maxSelected === null
      || (Number.isInteger(maxSelected) && maxSelected >= 1 && minSelected <= maxSelected));
  const consistent = fields.every((field) =>
    (field.checkboxGroupMinSelected ?? 0) === minSelected
    && (field.checkboxGroupMaxSelected === undefined ? 1 : field.checkboxGroupMaxSelected) === maxSelected);
  return { maxSelected, minSelected, valid: validRange && consistent };
}