import * as asn1js from "asn1js";
import * as pvutils from "pvutils";
import { EMPTY_STRING } from "./constants";
import { AsnError } from "./errors";
import { PkiObject, PkiObjectParameters } from "./PkiObject";
import * as Schema from "./Schema";

const ALGORITHM_ID = "algorithmId";
const ALGORITHM_PARAMS = "algorithmParams";
const ALGORITHM = "algorithm";
const PARAMS = "params";
const CLEAR_PROPS = [
  ALGORITHM,
  PARAMS
];

export interface IAlgorithmIdentifier {
  /**
   * ObjectIdentifier for algorithm (string representation)
   */
  algorithmId: string;
  /**
   * Any algorithm parameters
   */
  algorithmParams?: any;
}

export type AlgorithmIdentifierParameters = PkiObjectParameters & Partial<IAlgorithmIdentifier>;

/**
 * JSON representation of {@link AlgorithmIdentifier}
 */
export interface AlgorithmIdentifierJson {
  algorithmId: string;
  algorithmParams?: any;
}

export type AlgorithmIdentifierSchema = Schema.SchemaParameters<{
  algorithmIdentifier?: string;
  algorithmParams?: string;
}>;

/**
 * Represents the AlgorithmIdentifier structure described in [RFC5280](https://datatracker.ietf.org/doc/html/rfc5280)
 */
export class AlgorithmIdentifier extends PkiObject implements IAlgorithmIdentifier {

  public static override CLASS_NAME = "AlgorithmIdentifier";

  public algorithmId!: string;
  public algorithmParams?: any;

  /**
   * Initializes a new instance of the {@link AlgorithmIdentifier} class
   * @param parameters Initialization parameters
   */
  constructor(parameters: AlgorithmIdentifierParameters = {}) {
    super();

    this.algorithmId = pvutils.getParametersValue(parameters, ALGORITHM_ID, AlgorithmIdentifier.defaultValues(ALGORITHM_ID));
    if (ALGORITHM_PARAMS in parameters) {
      this.algorithmParams = pvutils.getParametersValue(parameters, ALGORITHM_PARAMS, AlgorithmIdentifier.defaultValues(ALGORITHM_PARAMS));
    }

    if (parameters.schema) {
      this.fromSchema(parameters.schema);
    }
  }

  /**
   * Returns default values for all class members
   * @param memberName String name for a class member
   * @returns Default value
   */
  public static override defaultValues(memberName: typeof ALGORITHM_ID): string;
  public static override defaultValues(memberName: typeof ALGORITHM_PARAMS): any;
  public static override defaultValues(memberName: string): any {
    switch (memberName) {
      case ALGORITHM_ID:
        return EMPTY_STRING;
      case ALGORITHM_PARAMS:
        return new asn1js.Any();
      default:
        return super.defaultValues(memberName);
    }
  }

  /**
   * Compares values with default values for all class members
   * @param memberName String name for a class member
   * @param memberValue Value to compare with default value
   */
  static compareWithDefault(memberName: string, memberValue: any): boolean {
    switch (memberName) {
      case ALGORITHM_ID:
        return (memberValue === EMPTY_STRING);
      case ALGORITHM_PARAMS:
        return (memberValue instanceof asn1js.Any);
      default:
        return super.defaultValues(memberName);
    }
  }

  /**
   * @inheritdoc
   * @asn ASN.1 schema
   * ```asn
   * AlgorithmIdentifier ::= Sequence  {
   *    algorithm               OBJECT IDENTIFIER,
   *    parameters              ANY DEFINED BY algorithm OPTIONAL  }
   *```
   */
  public static override schema(parameters: AlgorithmIdentifierSchema = {}): any {
    const names = pvutils.getParametersValue<NonNullable<typeof parameters.names>>(parameters, "names", {});

    return (new asn1js.Sequence({
      name: (names.blockName || EMPTY_STRING),
      optional: (names.optional || false),
      value: [
        new asn1js.ObjectIdentifier({ name: (names.algorithmIdentifier || EMPTY_STRING) }),
        new asn1js.Any({ name: (names.algorithmParams || EMPTY_STRING), optional: true })
      ]
    }));
  }

  public fromSchema(schema: Schema.SchemaType): void {
    // Clear input data first
    pvutils.clearProps(schema, CLEAR_PROPS);

    // Check the schema is valid
    const asn1 = asn1js.compareSchema(schema,
      schema,
      AlgorithmIdentifier.schema({
        names: {
          algorithmIdentifier: ALGORITHM,
          algorithmParams: PARAMS
        }
      })
    );
    AsnError.assertSchema(asn1, this.className);

    // Get internal properties from parsed schema
    this.algorithmId = asn1.result.algorithm.valueBlock.toString();
    if (PARAMS in asn1.result) {
      this.algorithmParams = asn1.result.params;
    }
  }

  public toSchema(): asn1js.Sequence {
    // Create array for output sequence
    const outputArray = [];
    outputArray.push(new asn1js.ObjectIdentifier({ value: this.algorithmId }));
    if (this.algorithmParams && !(this.algorithmParams instanceof asn1js.Any)) {
      outputArray.push(this.algorithmParams);
    }

    // Construct and return new ASN.1 schema for this object
    return (new asn1js.Sequence({
      value: outputArray
    }));
  }

  public toJSON(): AlgorithmIdentifierJson {
    const object: AlgorithmIdentifierJson = {
      algorithmId: this.algorithmId
    };

    if (this.algorithmParams && !(this.algorithmParams instanceof asn1js.Any)) {
      object.algorithmParams = this.algorithmParams.toJSON();
    }

    return object;
  }

  /**
   * Checks that two "AlgorithmIdentifiers" are equal
   * @param algorithmIdentifier
   */
  public isEqual(algorithmIdentifier: unknown): boolean {
    //#region Check input type
    if (!(algorithmIdentifier instanceof AlgorithmIdentifier)) {
      return false;
    }
    //#endregion

    //#region Check "algorithm_id"
    if (this.algorithmId !== algorithmIdentifier.algorithmId) {
      return false;
    }
    //#endregion

    //#region Check "algorithm_params"
    if (this.algorithmParams) {
      if (algorithmIdentifier.algorithmParams) {
        return JSON.stringify(this.algorithmParams) === JSON.stringify(algorithmIdentifier.algorithmParams);
      }

      return false;
    }

    if (algorithmIdentifier.algorithmParams) {
      return false;
    }
    //#endregion

    return true;
  }

}