import type { AxiosResponse } from 'axios';

import { request } from '@/utils/request';

import { commandHeaders } from './command';

export const ARCHIVE_API_BASE = '/archives';

const array = <T>(value: T[] | null | undefined): T[] => (Array.isArray(value) ? value : []);

export interface ArchivePageMeta {
  page: number;
  size: number;
  totalElements: number;
  totalPages: number;
}

export interface ArchiveReference {
  publicId: string;
  businessNo: string;
  name: string;
}

export interface ArchivePackageItem {
  publicId: string;
  itemType: string;
  itemName: string;
  objectType?: string | null;
  objectPublicId?: string | null;
  filePublicId?: string | null;
  fileName?: string | null;
  fileSha256?: string | null;
  required: boolean;
  status: string;
  missingReason?: string | null;
  returnReason?: string | null;
  notApplicableReason?: string | null;
  notApplicableRequestedByName?: string | null;
  notApplicableRequestedAt?: string | null;
  notApplicableReviewedByName?: string | null;
  notApplicableReviewedAt?: string | null;
  notApplicableReviewOpinion?: string | null;
  allowedActions: string[];
}

export interface ArchivePackageAction {
  sequenceNo: number;
  actionCode: string;
  fromStatus?: string | null;
  toStatus?: string | null;
  opinion?: string | null;
  actorName?: string | null;
  occurredAt: string;
  manifestSha256?: string | null;
}

export interface ArchivePackageObjectSnapshot {
  publicId: string;
  itemType: string;
  objectType: string;
  objectPublicId: string;
  objectBusinessNo?: string | null;
  objectName?: string | null;
  objectStatus: string;
  objectVersion?: number | null;
  objectFormType?: string | null;
  sourceVersionPublicId?: string | null;
  snapshotSha256: string;
  capturedAt: string;
}

export interface ArchivePackage {
  publicId: string;
  businessNo: string;
  company: ArchiveReference;
  project: ArchiveReference;
  packageVersion: number;
  rootPackagePublicId?: string | null;
  supersedesPackagePublicId?: string | null;
  revisionReason?: string | null;
  ruleVersion: string;
  completeness: string;
  missingCount: number;
  retentionYears: number;
  retentionExpiresOn?: string | null;
  retentionStatus: 'PENDING' | 'ACTIVE' | 'DUE_SOON' | 'EXPIRED' | 'FROZEN';
  physicalLocation?: string | null;
  frozen: boolean;
  status: string;
  manifestSha256?: string | null;
  submittedByName?: string | null;
  reviewedByName?: string | null;
  submittedAt?: string | null;
  archivedAt?: string | null;
  updatedAt: string;
  version: number;
  allowedActions: string[];
  items: ArchivePackageItem[];
  objectSnapshots: ArchivePackageObjectSnapshot[];
  actions: ArchivePackageAction[];
}

export interface ArchiveFile {
  publicId: string;
  displayName: string;
  mediaType: string;
  originalType?: string | null;
  sizeBytes: number;
  sha256: string;
  scanStatus: string;
  companyPublicId: string;
  companyName: string;
  projectPublicId: string;
  projectBusinessNo: string;
  projectName: string;
  contractPublicId?: string | null;
  counterpartyPublicId?: string | null;
  formType?: string | null;
  documentType: string;
  seriesPublicId: string;
  versionNo: number;
  archiveStatus: string;
  borrowStatus?: string | null;
  packagePublicId?: string | null;
  packageStatus?: string | null;
  uploadedBy: string;
  uploadedAt: string;
  sensitive: boolean;
  allowedActions: string[];
}

export interface ArchiveFileDetail {
  file: ArchiveFile;
  versions: ArchiveFile[];
  borrows: ArchiveBorrow[];
}

export interface ArchiveBorrow {
  publicId: string;
  businessNo: string;
  filePublicId: string;
  fileName: string;
  projectPublicId: string;
  projectName: string;
  purpose: string;
  dueAt: string;
  status: string;
  applicantName: string;
  approvedByName?: string | null;
  approvedAt?: string | null;
  reviewOpinion?: string | null;
  returnCondition?: string | null;
  returnedByName?: string | null;
  returnedAt?: string | null;
  version: number;
  allowedActions: string[];
}

export interface ArchivePackageQuery {
  view?: 'prepare' | 'check' | 'returned' | 'archived';
  companyId?: string;
  projectId?: string;
  status?: string;
  completeness?: string;
  frozen?: boolean;
  keyword?: string;
  sort?: string;
  page: number;
  size: number;
}

export interface ArchiveFileQuery {
  companyId?: string;
  projectId?: string;
  contractId?: string;
  counterpartyId?: string;
  formType?: string;
  fileName?: string;
  uploadedBy?: string;
  uploadedDateFrom?: string;
  uploadedDateTo?: string;
  originalType?: string;
  archiveStatus?: string;
  scanStatus?: string;
  sort?: string;
  page: number;
  size: number;
}

export interface ArchiveBorrowQuery {
  status?: string;
  keyword?: string;
  page: number;
  size: number;
}

export interface ArchivePackageCreatePayload {
  projectId: string;
  retentionYears?: number;
  physicalLocation?: string;
}

export interface ArchivePackageCommandPayload {
  version: number;
  opinion?: string;
  returnItemIds?: string[];
}

export interface ArchiveFreezePayload {
  version: number;
  reason: string;
}

export interface ArchivePackageRevisionPayload {
  version: number;
  reason: string;
}

export interface ArchiveNotApplicablePayload {
  version: number;
  reason: string;
}

export interface ArchiveNotApplicableReviewPayload {
  version: number;
  approved: boolean;
  opinion: string;
}

export interface ArchiveFileMetadata {
  projectId: string;
  packageId?: string;
  packageItemId?: string;
  contractId?: string;
  counterpartyId?: string;
  formType?: string;
  fileType: string;
  originalType?: string;
  replacesFileId?: string;
  replacementReason?: string;
  notApplicableReason?: string;
}

export interface ArchiveBorrowCreatePayload {
  fileId: string;
  purpose: string;
  dueAt: string;
}

export interface ArchiveBorrowCommandPayload {
  version: number;
  opinion?: string;
  returnCondition?: string;
}

interface PageEnvelope<T> {
  data: T[];
  meta: ArchivePageMeta;
  requestId: string;
}

export function normalizeArchivePackageItem(item: Partial<ArchivePackageItem> | null | undefined): ArchivePackageItem {
  return { ...(item || {}), allowedActions: array(item?.allowedActions) } as ArchivePackageItem;
}

export function normalizeArchivePackage(value: Partial<ArchivePackage> | null | undefined): ArchivePackage {
  const item = value || {};
  return {
    ...item,
    allowedActions: array(item.allowedActions),
    items: array(item.items).map(normalizeArchivePackageItem),
    objectSnapshots: array(item.objectSnapshots),
    actions: array(item.actions),
  } as ArchivePackage;
}

export function normalizeArchiveFile(value: Partial<ArchiveFile> | null | undefined): ArchiveFile {
  return { ...(value || {}), allowedActions: array(value?.allowedActions) } as ArchiveFile;
}

export function normalizeArchiveBorrow(value: Partial<ArchiveBorrow> | null | undefined): ArchiveBorrow {
  return { ...(value || {}), allowedActions: array(value?.allowedActions) } as ArchiveBorrow;
}

export function normalizeArchiveFileDetail(value: Partial<ArchiveFileDetail> | null | undefined): ArchiveFileDetail {
  return {
    ...(value || {}),
    file: normalizeArchiveFile(value?.file),
    versions: array(value?.versions).map(normalizeArchiveFile),
    borrows: array(value?.borrows).map(normalizeArchiveBorrow),
  } as ArchiveFileDetail;
}

export function archiveErrorText(error: unknown, fallback: string): string {
  const value = error as Error & { status?: number; code?: string; fieldErrors?: Record<string, string> };
  const fields = value.fieldErrors ? Object.values(value.fieldErrors).join('；') : '';
  if (value.status === 401) return '登录会话已失效，请重新登录后重试。';
  if (value.status === 403) return '当前身份没有访问该数据或执行该操作的权限。';
  if (value.status === 404) return '记录不存在、已被删除或当前身份无权查看。';
  if (value.code === 'VERSION_CONFLICT' || value.status === 409)
    return value.message || '数据已发生变化，请刷新后重试。';
  if (value.status === 422) {
    return fields
      ? `${value.message || '当前条件不满足业务规则'}：${fields}`
      : value.message || '当前条件不满足业务规则，请检查后重试。';
  }
  if (value.status && value.status >= 500) return value.message || '服务处理失败，请稍后重试。';
  return fields ? `${value.message || fallback}：${fields}` : value.message || fallback;
}

async function page<T>(url: string, params: Record<string, unknown>) {
  const envelope = await request.get<PageEnvelope<T>>({ url, params }, { isTransformResponse: false });
  return {
    items: array(envelope.data),
    meta: envelope.meta || {
      page: Number(params.page) || 1,
      size: Number(params.size) || 20,
      totalElements: 0,
      totalPages: 0,
    },
    requestId: envelope.requestId,
  };
}

export function getArchivePackages(params: ArchivePackageQuery) {
  return page<ArchivePackage>(`${ARCHIVE_API_BASE}/packages`, params as unknown as Record<string, unknown>).then(
    (result) => ({
      ...result,
      items: result.items.map(normalizeArchivePackage),
    }),
  );
}

export function getArchivePackage(publicId: string) {
  return request.get<ArchivePackage>({ url: `${ARCHIVE_API_BASE}/packages/${publicId}` }).then(normalizeArchivePackage);
}

export function createArchivePackage(payload: ArchivePackageCreatePayload, idempotencyKey?: string) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages`,
      data: payload,
      ...commandHeaders('archive-package-create', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function checkArchivePackage(publicId: string, payload: ArchivePackageCommandPayload, idempotencyKey?: string) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${publicId}/check`,
      data: payload,
      ...commandHeaders('archive-package-check', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function submitArchivePackage(publicId: string, payload: ArchivePackageCommandPayload, idempotencyKey?: string) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${publicId}/submit`,
      data: payload,
      ...commandHeaders('archive-package-submit', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function returnArchivePackage(publicId: string, payload: ArchivePackageCommandPayload, idempotencyKey?: string) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${publicId}/return`,
      data: payload,
      ...commandHeaders('archive-package-return', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function reviseArchivePackage(
  publicId: string,
  payload: ArchivePackageRevisionPayload,
  idempotencyKey?: string,
) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${publicId}/revise`,
      data: payload,
      ...commandHeaders('archive-package-revise', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function archiveArchivePackage(
  publicId: string,
  payload: ArchivePackageCommandPayload,
  idempotencyKey?: string,
) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${publicId}/archive`,
      data: payload,
      ...commandHeaders('archive-package-archive', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function freezeArchivePackage(publicId: string, payload: ArchiveFreezePayload, idempotencyKey?: string) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${publicId}/freeze`,
      data: payload,
      ...commandHeaders('archive-package-freeze', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function unfreezeArchivePackage(
  publicId: string,
  payload: ArchivePackageCommandPayload,
  idempotencyKey?: string,
) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${publicId}/unfreeze`,
      data: payload,
      ...commandHeaders('archive-package-unfreeze', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function markArchiveItemNotApplicable(
  packageId: string,
  itemId: string,
  payload: ArchiveNotApplicablePayload,
  idempotencyKey?: string,
) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${packageId}/items/${itemId}/not-applicable`,
      data: payload,
      ...commandHeaders('archive-item-not-applicable', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function reviewArchiveItemNotApplicable(
  packageId: string,
  itemId: string,
  payload: ArchiveNotApplicableReviewPayload,
  idempotencyKey?: string,
) {
  return request
    .post<ArchivePackage>({
      url: `${ARCHIVE_API_BASE}/packages/${packageId}/items/${itemId}/not-applicable/review`,
      data: payload,
      ...commandHeaders('archive-item-not-applicable-review', idempotencyKey),
    })
    .then(normalizeArchivePackage);
}

export function getArchiveFiles(params: ArchiveFileQuery) {
  return page<ArchiveFile>(`${ARCHIVE_API_BASE}/files`, params as unknown as Record<string, unknown>).then(
    (result) => ({
      ...result,
      items: result.items.map(normalizeArchiveFile),
    }),
  );
}

export function getArchiveFile(publicId: string) {
  return request
    .get<ArchiveFileDetail>({ url: `${ARCHIVE_API_BASE}/files/${publicId}` })
    .then(normalizeArchiveFileDetail);
}

export function rescanArchiveFile(publicId: string, idempotencyKey?: string) {
  return request
    .post<ArchiveFile>({
      url: `${ARCHIVE_API_BASE}/files/${publicId}/rescan`,
      data: {},
      ...commandHeaders('archive-file-rescan', idempotencyKey),
    })
    .then(normalizeArchiveFile);
}

export function getArchiveFileContent(publicId: string, preview = false) {
  return request.get<AxiosResponse<Blob>>(
    { url: `${ARCHIVE_API_BASE}/files/${publicId}/content`, params: { preview }, responseType: 'blob' },
    { isReturnNativeResponse: true },
  );
}

export function uploadArchiveFile(metadata: ArchiveFileMetadata, file: File, idempotencyKey?: string) {
  const formData = new FormData();
  formData.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
  formData.append('file', file, file.name);
  return request
    .post<ArchiveFile>({
      url: `${ARCHIVE_API_BASE}/files`,
      data: formData,
      headers: {
        'Content-Type': 'multipart/form-data',
        ...commandHeaders('archive-file-upload', idempotencyKey).headers,
      },
    })
    .then(normalizeArchiveFile);
}

export function getArchiveBorrows(params: ArchiveBorrowQuery) {
  return page<ArchiveBorrow>(`${ARCHIVE_API_BASE}/borrows`, params as unknown as Record<string, unknown>).then(
    (result) => ({
      ...result,
      items: result.items.map(normalizeArchiveBorrow),
    }),
  );
}

export function createArchiveBorrow(payload: ArchiveBorrowCreatePayload, idempotencyKey?: string) {
  return request
    .post<ArchiveBorrow>({
      url: `${ARCHIVE_API_BASE}/borrows`,
      data: payload,
      ...commandHeaders('archive-borrow-create', idempotencyKey),
    })
    .then(normalizeArchiveBorrow);
}

export function approveArchiveBorrow(publicId: string, payload: ArchiveBorrowCommandPayload, idempotencyKey?: string) {
  return request
    .post<ArchiveBorrow>({
      url: `${ARCHIVE_API_BASE}/borrows/${publicId}/approve`,
      data: payload,
      ...commandHeaders('archive-borrow-approve', idempotencyKey),
    })
    .then(normalizeArchiveBorrow);
}

export function rejectArchiveBorrow(publicId: string, payload: ArchiveBorrowCommandPayload, idempotencyKey?: string) {
  return request
    .post<ArchiveBorrow>({
      url: `${ARCHIVE_API_BASE}/borrows/${publicId}/reject`,
      data: payload,
      ...commandHeaders('archive-borrow-reject', idempotencyKey),
    })
    .then(normalizeArchiveBorrow);
}

export function returnArchiveBorrow(publicId: string, payload: ArchiveBorrowCommandPayload, idempotencyKey?: string) {
  return request
    .post<ArchiveBorrow>({
      url: `${ARCHIVE_API_BASE}/borrows/${publicId}/return`,
      data: payload,
      ...commandHeaders('archive-borrow-return', idempotencyKey),
    })
    .then(normalizeArchiveBorrow);
}