import type {
  FillDataResponse,
  FillFieldData,
  FillFieldType,
  RepeatAppendForm,
  RepeatDeleteForm,
  RepeatGroup,
  RepeatRestoreForm,
  RepeatRow,
  SourceSyncCommand,
  SourceSyncDifference,
  SourceSyncPreview,
  SourceSynchronized,
  StepFillStructure,
} from '../domain/types';

import { parseTag } from '../domain/tags';

const FIELD_TYPES = new Set<FillFieldType>(['text', 'multiline', 'select', 'checkbox', 'date']);

export class FillDataError extends Error {
  constructor(message: string, public readonly status?: number) {
    super(message);
    this.name = 'FillDataError';
  }
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

export function parseFillData(raw: unknown): FillDataResponse {
  if (!isRecord(raw) || !isRecord(raw.fields)) throw new Error('填写数据格式无效');
  const fields: Record<string, FillFieldData> = {};
  const checkboxGroupRules = new Map<string, string>();
  for (const [tag, value] of Object.entries(raw.fields)) {
    if (!tag || !isRecord(value) || !FIELD_TYPES.has(value.type as FillFieldType)) throw new Error('填写数据格式无效');
    if (value.required !== undefined && typeof value.required !== 'boolean') throw new Error('填写数据格式无效');
    if (value.readOnly !== undefined && typeof value.readOnly !== 'boolean') throw new Error('填写数据格式无效');
    if (value.valueSource !== undefined && typeof value.valueSource !== 'string') throw new Error('填写数据格式无效');
    if (value.formulaStatus !== undefined && !['ERROR', 'MISSING_INPUT', 'SUCCESS'].includes(String(value.formulaStatus))) {
      throw new Error('填写数据格式无效');
    }
    if (value.formulaMessage !== undefined && typeof value.formulaMessage !== 'string') throw new Error('填写数据格式无效');
    const type = value.type as FillFieldType;
    const parsedTag = parseTag(tag);
    const hasCheckboxGroup = value.checkboxGroupCode !== undefined;
    const hasCheckboxGroupMin = value.checkboxGroupMinSelected !== undefined;
    const hasCheckboxGroupMax = value.checkboxGroupMaxSelected !== undefined;
    if (hasCheckboxGroup && (!validIdentity(value.checkboxGroupCode)
      || type !== 'checkbox' || value.readOnly === true || parsedTag?.type === 'reference')) {
      throw new Error('填写数据格式无效');
    }
    if (!hasCheckboxGroup && (hasCheckboxGroupMin || hasCheckboxGroupMax)) throw new Error('填写数据格式无效');
    if (hasCheckboxGroup && hasCheckboxGroupMin !== hasCheckboxGroupMax) throw new Error('填写数据格式无效');
    const checkboxGroupMinSelected = hasCheckboxGroupMin ? value.checkboxGroupMinSelected : 0;
    const checkboxGroupMaxSelected = hasCheckboxGroupMax ? value.checkboxGroupMaxSelected : 1;
    if (hasCheckboxGroup && (!Number.isInteger(checkboxGroupMinSelected)
      || Number(checkboxGroupMinSelected) < 0
      || (checkboxGroupMaxSelected !== null
        && (!Number.isInteger(checkboxGroupMaxSelected)
          || Number(checkboxGroupMaxSelected) < 1
          || Number(checkboxGroupMinSelected) > Number(checkboxGroupMaxSelected))))) {
      throw new Error('填写数据格式无效');
    }
    if (hasCheckboxGroup) {
      const groupCode = value.checkboxGroupCode as string;
      const ruleIdentity = `${checkboxGroupMinSelected}:${checkboxGroupMaxSelected === null ? '*' : checkboxGroupMaxSelected}`;
      if (checkboxGroupRules.has(groupCode) && checkboxGroupRules.get(groupCode) !== ruleIdentity) {
        throw new Error('填写数据格式无效');
      }
      checkboxGroupRules.set(groupCode, ruleIdentity);
    }
    const metadata = {
      ...(hasCheckboxGroup
        ? {
            checkboxGroupCode: value.checkboxGroupCode as string,
            checkboxGroupMaxSelected: checkboxGroupMaxSelected as null | number,
            checkboxGroupMinSelected: checkboxGroupMinSelected as number,
          }
        : {}),
      ...(typeof value.formulaMessage === 'string' ? { formulaMessage: value.formulaMessage } : {}),
      ...(typeof value.formulaStatus === 'string'
        ? { formulaStatus: value.formulaStatus as FillFieldData['formulaStatus'] }
        : {}),
      ...(value.readOnly === true ? { readOnly: true } : {}),
      required: value.required === true,
      ...(typeof value.valueSource === 'string' ? { valueSource: value.valueSource } : {}),
    };
    if (type === 'checkbox') {
      if (value.value !== null && typeof value.value !== 'boolean') throw new Error('填写数据格式无效');
      fields[tag] = { ...metadata, type, value: value.value ?? false };
    } else {
      if (value.value !== null && typeof value.value !== 'string') throw new Error('填写数据格式无效');
      fields[tag] = { ...metadata, type, value: value.value as null | string };
    }
  }
  const repeatFieldGroups = new Map<string, string>();
  for (const [tag, field] of Object.entries(fields)) {
    const parsed = parseTag(tag);
    if (parsed?.type !== 'repeat') continue;
    const key = `${parsed.groupCode}\n${parsed.fieldCode}`;
    const ruleIdentity = field.checkboxGroupCode
      ? `${field.checkboxGroupCode}:${field.checkboxGroupMinSelected}:${field.checkboxGroupMaxSelected === null ? '*' : field.checkboxGroupMaxSelected}`
      : '';
    if (repeatFieldGroups.has(key)
      && repeatFieldGroups.get(key) !== ruleIdentity) throw new Error('填写数据格式无效');
    repeatFieldGroups.set(key, ruleIdentity);
  }
  const repeatGroups = raw.repeatGroups === undefined ? [] : parseRepeatGroups(raw.repeatGroups);
  const stepStructure = raw.stepStructure === undefined ? undefined : parseStepStructure(raw.stepStructure);
  const pendingSourceSync = raw.pendingSourceSync === undefined || raw.pendingSourceSync === null
    ? undefined
    : parseSourceSynchronized(raw.pendingSourceSync);
  return {
    fields,
    repeatGroups,
    ...(pendingSourceSync ? { pendingSourceSync } : {}),
    ...(stepStructure ? { stepStructure } : {}),
  };
}

function validIdentity(value: unknown): value is string {
  return typeof value === 'string' && /^[\w-]{1,80}$/u.test(value);
}

function parseRepeatRow(value: unknown, expectedGroup?: string): RepeatRow {
  if (!isRecord(value) || !validIdentity(value.groupCode) || !validIdentity(value.rowId)
    || value.rowId === 'prototype' || value.groupCode !== (expectedGroup ?? value.groupCode)
    || !Number.isInteger(value.rowOrder) || Number(value.rowOrder) < 1
    || !['ACTIVE', 'DELETE_PREPARED', 'PREPARED'].includes(String(value.status))) {
    throw new Error('填写数据格式无效');
  }
  if (value.deleteOperationCode !== undefined && value.deleteOperationCode !== null
    && typeof value.deleteOperationCode !== 'string') throw new Error('填写数据格式无效');
  if (value.deleteReason !== undefined && value.deleteReason !== null
    && typeof value.deleteReason !== 'string') throw new Error('填写数据格式无效');
  if (value.status === 'DELETE_PREPARED'
    && (!value.deleteOperationCode || !value.deleteReason)) throw new Error('填写数据格式无效');
  return value as unknown as RepeatRow;
}

function parseRepeatGroups(value: unknown): RepeatGroup[] {
  if (!Array.isArray(value)) throw new Error('填写数据格式无效');
  const groups = new Set<string>();
  return value.map((item) => {
    if (!isRecord(item) || !validIdentity(item.groupCode) || groups.has(item.groupCode)
      || !Number.isInteger(item.minRows) || !Number.isInteger(item.maxRows)
      || !Number.isInteger(item.activeRowCount)
      || Number(item.minRows) < 0 || Number(item.maxRows) < Number(item.minRows)
      || Number(item.activeRowCount) < 0 || !Array.isArray(item.rows)) {
      throw new Error('填写数据格式无效');
    }
    groups.add(item.groupCode);
    const rows = item.rows.map((row) => parseRepeatRow(row, item.groupCode as string));
    if (rows.length !== item.activeRowCount) throw new Error('填写数据格式无效');
    const checkboxGroups: Record<string, string> = {};
    if (item.checkboxGroups !== undefined) {
      if (!isRecord(item.checkboxGroups)) throw new Error('填写数据格式无效');
      for (const [fieldCode, checkboxGroupCode] of Object.entries(item.checkboxGroups)) {
        if (!validIdentity(fieldCode) || !validIdentity(checkboxGroupCode)) {
          throw new Error('填写数据格式无效');
        }
        checkboxGroups[fieldCode] = checkboxGroupCode;
      }
    }
    return { ...item, checkboxGroups, rows } as unknown as RepeatGroup;
  });
}

function parseStepStructure(value: unknown): StepFillStructure {
  if (!isRecord(value) || !isRecord(value.configuration)
    || typeof value.configuration.singleStep !== 'boolean'
    || !Array.isArray(value.configuration.steps)) throw new Error('填写数据格式无效');
  const stepIds = new Set<string>();
  const steps = value.configuration.steps.map((step) => {
    if (!isRecord(step) || !validIdentity(step.id) || stepIds.has(step.id)
      || typeof step.name !== 'string' || !step.name.trim()
      || !Number.isInteger(step.order) || Number(step.order) < 1) throw new Error('填写数据格式无效');
    stepIds.add(step.id);
    return {
      id: step.id,
      name: step.name,
      order: Number(step.order),
    };
  });
  if (steps.length < 1 || steps.length > 20
    || (value.configuration.singleStep && steps.length !== 1)) throw new Error('填写数据格式无效');
  const parseAssignments = (assignments: unknown, repeatGroups: boolean): Record<string, string> => {
    if (!isRecord(assignments)) throw new Error('填写数据格式无效');
    const result: Record<string, string> = {};
    for (const [key, stepId] of Object.entries(assignments)) {
      if ((!key || (repeatGroups && !validIdentity(key)))
        || !validIdentity(stepId) || !stepIds.has(stepId)) throw new Error('填写数据格式无效');
      result[key] = stepId;
    }
    return result;
  };
  return {
    configuration: { singleStep: value.configuration.singleStep, steps },
    controlSteps: parseAssignments(value.controlSteps, false),
    repeatGroupSteps: parseAssignments(value.repeatGroupSteps, true),
  };
}

function messageFor(status: number): string {
  if (status === 401) return '填写凭证已过期，请重新打开文档';
  if (status === 403) return '无权读取填写数据';
  if (status === 404) return '填写数据不存在';
  return '填写数据加载失败';
}

function parseSourceSyncDifference(value: unknown): SourceSyncDifference {
  const optionalStrings = [
    value && typeof value === 'object' ? (value as Record<string, unknown>).sourceFetchedAt : undefined,
    value && typeof value === 'object' ? (value as Record<string, unknown>).sourceFieldVersionId : undefined,
    value && typeof value === 'object' ? (value as Record<string, unknown>).sourceRecordId : undefined,
    value && typeof value === 'object' ? (value as Record<string, unknown>).sourceRevisionId : undefined,
    value && typeof value === 'object' ? (value as Record<string, unknown>).sourceValueId : undefined,
  ];
  if (!isRecord(value)
    || typeof value.bindingId !== 'string' || !value.bindingId
    || typeof value.fieldCode !== 'string' || !value.fieldCode
    || typeof value.fieldName !== 'string'
    || typeof value.dataType !== 'string' || !value.dataType
    || !['CROSS_TEMPLATE', 'LIMS_TASK'].includes(String(value.sourceType))
    || (value.sourceProperty !== undefined && value.sourceProperty !== null && typeof value.sourceProperty !== 'string')
    || (value.sourceType === 'LIMS_TASK' && (typeof value.sourceProperty !== 'string' || !value.sourceProperty))
    || typeof value.changed !== 'boolean'
    || optionalStrings.some((item) => item !== undefined && item !== null && typeof item !== 'string')
    || (value.previousValue !== undefined && value.previousValue !== null && typeof value.previousValue !== 'string')
    || (value.currentValue !== undefined && value.currentValue !== null && typeof value.currentValue !== 'string')) {
    throw new FillDataError('来源快照同步响应无效');
  }
  return value as unknown as SourceSyncDifference;
}

function sourceSyncBase(value: unknown) {
  if (!isRecord(value)
    || typeof value.recordId !== 'string' || !value.recordId
    || typeof value.revisionId !== 'string' || !value.revisionId
    || !Number.isInteger(value.recordVersion) || Number(value.recordVersion) < 0
    || !Number.isInteger(value.changedCount) || Number(value.changedCount) < 0
    || !Array.isArray(value.differences)) {
    throw new FillDataError('来源快照同步响应无效');
  }
  return {
    changedCount: Number(value.changedCount),
    differences: value.differences.map(parseSourceSyncDifference),
    recordId: value.recordId,
    recordVersion: Number(value.recordVersion),
    revisionId: value.revisionId,
  };
}

function parseSourceSyncPreview(value: unknown): SourceSyncPreview {
  const base = sourceSyncBase(value);
  if (!isRecord(value) || typeof value.previewToken !== 'string' || !value.previewToken) {
    throw new FillDataError('来源快照同步响应无效');
  }
  return { ...base, previewToken: value.previewToken };
}

function parseSourceSynchronized(value: unknown): SourceSynchronized {
  const base = sourceSyncBase(value);
  if (!isRecord(value) || typeof value.operationCode !== 'string' || !value.operationCode
    || !Number.isInteger(value.recalculatedCount) || Number(value.recalculatedCount) < 0
    || !Array.isArray(value.changedFieldCodes)
    || value.changedFieldCodes.some((fieldCode) => typeof fieldCode !== 'string' || !fieldCode)) {
    throw new FillDataError('来源快照同步响应无效');
  }
  return {
    ...base,
    changedFieldCodes: [...new Set(value.changedFieldCodes as string[])],
    operationCode: value.operationCode,
    recalculatedCount: Number(value.recalculatedCount),
  };
}

async function sourceSyncRequest(
  context: { apiBaseUrl: string; ticket: string },
  path: string,
  body?: SourceSyncCommand,
): Promise<unknown> {
  let response: Response;
  try {
    response = await fetch(`${context.apiBaseUrl}/api/eln/onlyoffice/recordFill/sourceSync${path}`, {
      method: 'POST',
      headers: {
        Authorization: `Ticket ${context.ticket}`,
        ...(body ? { 'Content-Type': 'application/json' } : {}),
      },
      ...(body ? { body: JSON.stringify(body) } : {}),
    });
  } catch {
    throw new FillDataError('来源快照同步失败');
  }
  if (!response.ok) throw new FillDataError(
    response.status === 401 ? '填写凭证已过期，请重新打开文档' : '来源快照同步失败',
    response.status,
  );
  try { return await response.json(); } catch { throw new FillDataError('来源快照同步响应无效'); }
}

export async function previewSourceSync(
  context: { apiBaseUrl: string; ticket: string },
): Promise<SourceSyncPreview> {
  return parseSourceSyncPreview(await sourceSyncRequest(context, '/preview'));
}

export async function synchronizeSource(
  context: { apiBaseUrl: string; ticket: string }, command: SourceSyncCommand,
): Promise<SourceSynchronized> {
  return parseSourceSynchronized(await sourceSyncRequest(context, '', command));
}

export async function fetchFillData(context: { apiBaseUrl: string; ticket: string }): Promise<FillDataResponse> {
  let response: Response;
  try {
    response = await fetch(`${context.apiBaseUrl}/api/eln/onlyoffice/recordFill/data`, {
      headers: { Authorization: `Ticket ${context.ticket}` },
    });
  } catch {
    throw new FillDataError('填写数据加载失败');
  }
  if (!response.ok) throw new FillDataError(messageFor(response.status), response.status);
  try {
    return parseFillData(await response.json());
  } catch (error) {
    if (error instanceof FillDataError) throw error;
    throw new FillDataError('填写数据格式无效');
  }
}

export async function appendRepeatRow(
  context: { apiBaseUrl: string; ticket: string },
  form: RepeatAppendForm,
): Promise<RepeatRow> {
  let response: Response;
  try {
    response = await fetch(`${context.apiBaseUrl}/api/eln/onlyoffice/recordFill/repeatRows`, {
      method: 'POST',
      headers: { Authorization: `Ticket ${context.ticket}`, 'Content-Type': 'application/json' },
      body: JSON.stringify(form),
    });
  } catch {
    throw new FillDataError('新增重复行失败');
  }
  if (!response.ok) throw new FillDataError(messageFor(response.status), response.status);
  let value: unknown;
  try { value = await response.json(); } catch { throw new FillDataError('新增重复行响应无效'); }
  if (!isRecord(value) || typeof value.groupCode !== 'string' || typeof value.rowId !== 'string'
    || typeof value.rowOrder !== 'number' || !['ACTIVE', 'PREPARED'].includes(String(value.status))) {
    throw new FillDataError('新增重复行响应无效');
  }
  return value as unknown as RepeatRow;
}

async function changeRepeatRow(
  context: { apiBaseUrl: string; ticket: string },
  action: 'delete' | 'restore',
  form: RepeatDeleteForm | RepeatRestoreForm,
): Promise<RepeatRow> {
  let response: Response;
  try {
    response = await fetch(`${context.apiBaseUrl}/api/eln/onlyoffice/recordFill/repeatRows/${action}`, {
      method: 'POST',
      headers: { Authorization: `Ticket ${context.ticket}`, 'Content-Type': 'application/json' },
      body: JSON.stringify(form),
    });
  } catch {
    throw new FillDataError(action === 'delete' ? '删除重复行失败' : '恢复重复行失败');
  }
  if (!response.ok) throw new FillDataError(messageFor(response.status), response.status);
  let value: unknown;
  try { value = await response.json(); } catch { throw new FillDataError('重复行响应无效'); }
  try { return parseRepeatRow(value); } catch { throw new FillDataError('重复行响应无效'); }
}

export function deleteRepeatRow(
  context: { apiBaseUrl: string; ticket: string }, form: RepeatDeleteForm,
): Promise<RepeatRow> {
  return changeRepeatRow(context, 'delete', form);
}

export function restoreRepeatRow(
  context: { apiBaseUrl: string; ticket: string }, form: RepeatRestoreForm,
): Promise<RepeatRow> {
  return changeRepeatRow(context, 'restore', form);
}