import type { DocumentField, FillDataResponse, FillFieldValue } from './types';

import { parseTag, primaryFieldTag } from './tags';

export interface DraftField extends DocumentField {
  checkboxGroupCode?: string;
  checkboxGroupMaxSelected?: null | number;
  checkboxGroupMinSelected?: number;
  documentValue: FillFieldValue;
  draftValue: FillFieldValue;
  formulaMessage?: string;
  formulaStatus?: 'ERROR' | 'MISSING_INPUT' | 'SUCCESS';
  readOnly?: boolean;
  required?: boolean;
  requiredKnown?: boolean;
  valueSource?: string;
}

function isEmpty(value: FillFieldValue): boolean {
  return typeof value === 'string' && value.trim() === '';
}

export function isReferenceTag(tag: string): boolean {
  return parseTag(tag)?.type === 'reference';
}

function dataTagForDocumentTag(tag: string): string {
  return primaryFieldTag(tag) ?? tag;
}

function sourceValue(field: DocumentField, data: FillDataResponse): FillFieldValue | undefined {
  const source = data.fields[dataTagForDocumentTag(field.tag)];
  if (source?.type !== field.type) return undefined;
  if (field.type === 'checkbox') return Boolean(source.value);
  return typeof source.value === 'string' ? source.value : '';
}

function requiredMetadata(field: DocumentField, data: FillDataResponse) {
  const direct = data.fields[dataTagForDocumentTag(field.tag)];
  if (direct) return { required: direct.required === true, requiredKnown: true };
  const parsed = parseTag(field.tag);
  if (parsed?.type !== 'repeat') {
    return { required: false, requiredKnown: false };
  }
  const matching = Object.entries(data.fields).find(([tag]) => {
    const candidate = parseTag(tag);
    return candidate?.type === 'repeat'
      && candidate.groupCode === parsed.groupCode && candidate.fieldCode === parsed.fieldCode;
  });
  return matching
    ? { required: matching[1].required === true, requiredKnown: true }
    : { required: false, requiredKnown: false };
}

function checkboxGroupMetadata(field: DocumentField, data: FillDataResponse) {
  if (field.type !== 'checkbox') return {};
  const parsed = parseTag(field.tag);
  if (!parsed || parsed.type === 'reference') return {};
  const direct = data.fields[field.tag];
  if (direct?.checkboxGroupCode) return checkboxGroupRule(direct);
  if (parsed.type !== 'repeat') return {};
  const matching = Object.entries(data.fields).find(([tag, candidate]) => {
    const candidateTag = parseTag(tag);
    return candidate.checkboxGroupCode
      && candidateTag?.type === 'repeat'
      && candidateTag.groupCode === parsed.groupCode
      && candidateTag.fieldCode === parsed.fieldCode;
  });
  if (matching?.[1].checkboxGroupCode) {
    return checkboxGroupRule(matching[1]);
  }
  const configured = data.repeatGroups.find((group) => group.groupCode === parsed.groupCode)
    ?.checkboxGroups?.[parsed.fieldCode];
  return configured
    ? { checkboxGroupCode: configured, checkboxGroupMaxSelected: 1, checkboxGroupMinSelected: 0 }
    : {};
}

function checkboxGroupRule(field: FillDataResponse['fields'][string]) {
  return {
    checkboxGroupCode: field.checkboxGroupCode,
    checkboxGroupMaxSelected: field.checkboxGroupMaxSelected,
    checkboxGroupMinSelected: field.checkboxGroupMinSelected,
  };
}

function fieldMetadata(field: DocumentField, data: FillDataResponse) {
  const source = data.fields[dataTagForDocumentTag(field.tag)];
  return {
    ...checkboxGroupMetadata(field, data),
    ...(source?.formulaMessage ? { formulaMessage: source.formulaMessage } : {}),
    ...(source?.formulaStatus ? { formulaStatus: source.formulaStatus } : {}),
    ...(source?.readOnly === true ? { readOnly: true } : {}),
    ...(source?.valueSource ? { valueSource: source.valueSource } : {}),
    ...requiredMetadata(field, data),
  };
}

export function buildDraftFields(
  documentFields: DocumentField[],
  data: FillDataResponse,
  options: { ignoreDataValues?: boolean; preferData?: boolean } = {},
): DraftField[] {
  return documentFields.map((field) => {
    let draftValue = field.currentValue;
    const value = options.ignoreDataValues ? undefined : sourceValue(field, data);
    if (value !== undefined) {
      if (options.preferData || field.type === 'checkbox') draftValue = value;
      else if (isEmpty(field.currentValue) && !isEmpty(value)) draftValue = value;
    }
    return { ...field, ...fieldMetadata(field, data), documentValue: field.currentValue, draftValue };
  });
}