import type { GetIdSdk } from '@get-id/react-native-sdk';
import uploadDocument from '../../api/uploadDocument';
import {
  DocumentConclusion,
  type CountryDocumentTypes,
  type DocumentType,
  type ScannedDocument,
} from '../../types/sdkTypes';
import type { UploadDocumentResponse } from '../../types/apiTypes';
import { mapResultToScannedDocument } from '../../api/utils/apiResultMapper';

type HandleCaptureUploadProps = {
  imageUri: string;
  docType: 'front' | 'back';
  sdk: GetIdSdk;
};

type HandleCaptureUploadResult = ScannedDocument;

const isDocumentCountryAllowed = (
  country: string,
  allowedList: CountryDocumentTypes[]
): boolean => {
  const allowedDoc = allowedList.find((doc) => doc.country === country);
  if (!allowedDoc) {
    return false;
  }
  return true;
};

const isDocumentTypeAllowed = (
  country: string,
  type: DocumentType,
  documentCid: number = 0,
  allowedList: CountryDocumentTypes[]
): boolean => {
  const allowedDoc = allowedList.find((doc) => doc.country === country);
  if (!allowedDoc) {
    return false;
  }

  const { excludedDocumentVersions } = allowedDoc;

  const excludedCids =
    excludedDocumentVersions
      ?.map((dv) => {
        try {
          const [cid = '0'] = dv?.split('_')?.reverse() || '0';
          return +cid;
        } catch (e) {
          return null;
        }
      })
      .filter(Boolean) || [];
  const isSupportedDocumentVersion = !excludedCids.includes(documentCid);

  if (!isSupportedDocumentVersion) {
    return false;
  }

  return allowedDoc.documentTypes?.includes(type) || false;
};

const isValidSupportedDoc = (
  supportedDoc: Partial<CountryDocumentTypes>
): boolean => {
  const allPropertiesArePresent =
    'country' in supportedDoc && 'documentTypes' in supportedDoc;
  if (allPropertiesArePresent) {
    const allPropertiesAreValid =
      (supportedDoc?.documentTypes?.length || 0) > 0 ||
      (supportedDoc?.excludedDocumentVersions?.length || 0) > 0;
    return allPropertiesAreValid;
  }
  return false;
};

const trimSupportedDocumentArray = (
  supportedDocs: CountryDocumentTypes[]
): CountryDocumentTypes[] => supportedDocs.filter(isValidSupportedDoc);

export const handleCaptureUpload = async ({
  imageUri,
  docType,
  sdk,
}: HandleCaptureUploadProps): Promise<HandleCaptureUploadResult> => {
  const uploadedDoc: UploadDocumentResponse = await uploadDocument({
    imageUri,
    docType,
    sdk,
  });

  const isConclusionOkay = [
    DocumentConclusion.OK,
    DocumentConclusion.BACK_SIDE_MISSING,
  ].includes(uploadedDoc.conclusion as DocumentConclusion);

  // If the document is not okay, return server's conclusion
  if (!isConclusionOkay) return mapResultToScannedDocument(uploadedDoc);

  if (
    docType === 'back' &&
    uploadedDoc.conclusion === DocumentConclusion.BACK_SIDE_MISSING
  ) {
    return mapResultToScannedDocument({
      ...uploadedDoc,
      conclusion: DocumentConclusion.BACK_SIDE_MISSING,
    });
  }

  const acceptableDocuments =
    typeof sdk.config.acceptableDocuments === 'function'
      ? await sdk.config.acceptableDocuments(
          sdk.config.stepsConfigs.document.countriesDocumentTypes
        )
      : sdk.config.acceptableDocuments ||
        sdk.config.stepsConfigs.document.countriesDocumentTypes;
  if (
    (sdk.config.acceptableDocuments ||
      sdk.config.stepsConfigs.document.countriesDocumentTypes) &&
    !isDocumentCountryAllowed(
      uploadedDoc.issuingCountry,
      trimSupportedDocumentArray(acceptableDocuments)
    )
  ) {
    return mapResultToScannedDocument({
      ...uploadedDoc,
      conclusion: DocumentConclusion.UNACCEPTABLE_COUNTRY,
    });
  }
  if (
    (sdk.config.acceptableDocuments ||
      sdk.config.stepsConfigs.document.countriesDocumentTypes) &&
    !isDocumentTypeAllowed(
      uploadedDoc.issuingCountry,
      uploadedDoc.documentType as DocumentType,
      uploadedDoc.documentCid,
      trimSupportedDocumentArray(acceptableDocuments)
    )
  ) {
    return mapResultToScannedDocument({
      ...uploadedDoc,
      conclusion: DocumentConclusion.UNACCEPTABLE_DOCUMENT_TYPE,
    });
  }

  sdk.addDocFile({
    type: docType,
    uri: imageUri,
    fileId: uploadedDoc.fileIds[docType] || '',
  });

  return mapResultToScannedDocument(uploadedDoc);
};

export default handleCaptureUpload;