import { JsonCredential } from './shared/dto/jsonCredential.dto.js';
import {
  CredentialValidationOptions,
  PresentationValidationOptions,
} from './shared/dto/validationOptions.dto.js';
import { DecodedVerifiableCredentialDto } from './shared/dto/decodedVerifiableCredential.dto.js';
import { VerifiableCredentialsValidator } from './validators/credential/verifiableCredentialsValidator.js';
import joseWrapper from './shared/middleware/joseWrapper.js';
import { CredentialValidatorFactory } from './validators/credentialValidatorFactory.js';
import { VpTokenCredentialsExtractor } from './validators/presentation/vpTokenCredentialsExtractor.js';
import { ValidationResult } from './shared/dto/validationResult.dto.js';
import { PresentationValidatorFactory } from './validators/presentationValidatorFactory.js';
import { JsonPresentation } from './shared/dto/jsonPresentation.dto.js';
import { areEqualObjects } from './shared/utils.js';
import { StatusListCredentialResponse } from './resolvers/statusListCredentialFetcher.js';
import { DidPublicKeyResolver } from './resolvers/didPublicKeyResolver.js';
import { DidDocumentResolver } from './resolvers/didDocumentResolver.js';
import { SignatureValidator } from './validators/credential/signatureValidator.js';
import { DataIntegrityProofValidator } from './validators/credential/dataIntegrityProofValidator.js';
import { validateDidAuthIdToken } from './didAuth-validator.js';
import { HttpPublicKeyResolver } from './resolvers/httpPublicKeyResolver.js';
import { DcqlPresentation } from './validators/presentation/dcqlPresentation.js';
import { StatusListDecoderFactory } from './statusList/statusListDecoderFactory.js';

export interface RevocationResult {
  revoked: boolean;
  message?: string;
}

async function validateJwtVC(
  credential: string,
  opts?: CredentialValidationOptions,
): Promise<ValidationResult> {
  const decodedVerifiableCredential = joseWrapper.decodeJWT(
    credential,
  ) as DecodedVerifiableCredentialDto;

  const credentialsValidator = CredentialValidatorFactory.create(
    decodedVerifiableCredential.iss,
  );

  return await credentialsValidator.validate(credential, opts);
}

async function validateJsonVC(
  credential: JsonCredential,
  opts?: CredentialValidationOptions,
): Promise<ValidationResult> {
  // ── VCDM 2.0: DataIntegrityProof (proofValue, no jws) ──────────────────
  if (credential.proof?.proofValue && !credential.proof?.jws) {
    const dataIntegrityValidator = new DataIntegrityProofValidator(
      new DidDocumentResolver(),
    );
    return dataIntegrityValidator.validate(credential, opts);
  }

  // ── VCDM 1.0: JSON-LD credential with embedded JWS proof ───────────────
  const verifiableCredentialsValidator = new VerifiableCredentialsValidator(
    new DidPublicKeyResolver(new DidDocumentResolver()),
    new HttpPublicKeyResolver(),
    new SignatureValidator(),
  );
  const decodedVerifiableCredential = joseWrapper.decodeJWT(
    credential.proof.jws,
  ) as DecodedVerifiableCredentialDto;
  const proof = credential.proof;
  const keyToRemove: keyof JsonPresentation = 'proof';
  delete credential[keyToRemove];
  if (
    credential.hasOwnProperty('issuanceDate') &&
    !decodedVerifiableCredential.vc.hasOwnProperty('issuanceDate')
  ) {
    delete credential['issuanceDate'];
  }
  if (
    decodedVerifiableCredential.vc.hasOwnProperty('issued') &&
    !credential.hasOwnProperty('issued')
  ) {
    delete decodedVerifiableCredential.vc['issued'];
  }
  if (!areEqualObjects(credential, decodedVerifiableCredential.vc)) {
    return {
      valid: false,
      messages: [
        `ValidationError: Mismatch between credential payload and jws. Credential: ${credential.id}`,
      ],
    };
  }
  credential.proof = proof;

  return verifiableCredentialsValidator.validate(credential.proof.jws, opts);
}

async function validateDcqlVp(
  presentation: DcqlPresentation,
  audience: string,
  opts: PresentationValidationOptions,
): Promise<ValidationResult> {
  const extractionResult = new VpTokenCredentialsExtractor(
    presentation,
    opts?.dcqlQuery,
  ).extract();

  if (!extractionResult.result.valid) {
    return { valid: false, messages: [extractionResult.result.message] };
  }

  opts.verifiablePresentationValidationReport?.addExtractionResult(
    extractionResult,
  );

  const presentationValidatorFactory = new PresentationValidatorFactory();
  const validator = presentationValidatorFactory.create(
    presentation,
    extractionResult.vpTokenData,
    opts,
  );

  return validator.validate(presentation, audience);
}

function checkRevocationStatus(
  credentialIndex: number,
  statusListCredential: string | StatusListCredentialResponse,
): RevocationResult {
  try {
    const revocationStatusList =
      StatusListDecoderFactory.getDecoderFromData(
        statusListCredential,
      ).getEncodedList(statusListCredential);

    return {
      revoked: revocationStatusList.isRevoked(credentialIndex),
    };
  } catch (error) {
    return {
      revoked: false,
      message: error.message,
    };
  }
}

async function validateDidAuthToken(
  id_token: string,
): Promise<ValidationResult> {
  return validateDidAuthIdToken(id_token);
}

export {
  validateJwtVC,
  validateJsonVC,
  validateDcqlVp,
  checkRevocationStatus,
  validateDidAuthToken,
};