export type HostedFieldsCardTypeName =
    | "amex"
    | "discover"
    | "elo"
    | "hiper"
    | "jcb"
    | "mastercard"
    | "visa";

export interface HostedFieldsCardTypeData {
    eligible: boolean;
    valuable: boolean;
}

export type HostedFieldsCardTypes = {
    [key in HostedFieldsCardTypeName]: HostedFieldsCardTypeData;
};

export interface HostedFieldsCardCode {
    name: string;
    size: number;
}

export interface HostedFieldsHostedFieldsCard {
    type: string;
    niceType: string;
    code: HostedFieldsCardCode;
}

export type HostedFieldsHostedFieldsFieldName =
    | "number"
    | "cvv"
    | "expirationDate"
    | "expirationMonth"
    | "expirationYear"
    | "postalCode"
    | "cardholderName";

export interface HostedFieldsHostedFieldsFieldData {
    container: HTMLElement;
    isEmpty: boolean;
    isFocused: boolean;
    isPotentiallyValid: boolean;
    isValid: boolean;
}

export type HostedFieldsFieldDataFields = {
    [key in HostedFieldsHostedFieldsFieldName]: HostedFieldsHostedFieldsFieldData;
};

export type HostedFieldsTokenize = {
    vault?: boolean;
    authenticationInsight?: unknown;
    fieldsToTokenize?: string[];
    cardholderName?: string;
    billingAddress?: {
        postalCode?: string;
        firstName?: string;
        lastName?: string;
        company?: string;
        streetAddress?: string;
        extendedAddress?: string;
        locality?: string;
        region?: string;
        countryCodeNumeric?: string;
        countryCodeAlpha2?: string;
        countryCodeAlpha3?: string;
        countryName?: string;
    };
};

export interface HostedFieldsState {
    cards: HostedFieldsHostedFieldsCard[];
    fields: HostedFieldsFieldDataFields;
}

export interface HostedFieldsEvent extends HostedFieldsState {
    emittedBy: HostedFieldsHostedFieldsFieldName;
}

export interface HostedFieldsEventTypeMap {
    blur: HostedFieldsEvent;
    focus: HostedFieldsEvent;
    empty: HostedFieldsEvent;
    notEmpty: HostedFieldsEvent;
    cardTypeChange: HostedFieldsEvent;
    validityChange: HostedFieldsEvent;
    inputSubmitRequest: HostedFieldsEvent;
}

export type HostedFieldEventType = keyof HostedFieldsEventTypeMap;

export type InstallmentsConfiguration = {
    currencyCode: string;
    amount: string;
    financingCountryCode?: string;
    billingCountryCode?: string;
};

export type AvailableInstallments = {
    configuration_owner_account: string;
    financing_options: Array<Record<string, unknown>>;
};

export interface Installments {
    /**
     * Defines the installments configuration
     */
    onInstallmentsRequested: () =>
        | Promise<InstallmentsConfiguration>
        | InstallmentsConfiguration;
    /**
     * Handle and use installments options
     */
    onInstallmentsAvailable: (installments: AvailableInstallments) => void;
    /**
     * Handle fetching installments errors
     */
    onInstallmentsError?: (error: Record<string, unknown>) => void;
}

export interface PayPalHostedFieldsComponentOptions {
    createOrder: () => Promise<string>;
    installments?: Installments;
    onError?: (err: Record<string, unknown>) => void;
    styles?: Record<string, unknown>;
    fields?: Record<string, unknown>;
}

export interface HostedFieldsSubmitResponse {
    orderId: string;
    liabilityShift?: string;
    liabilityShifted?: boolean;
    authenticationReason?: string;
    authenticationStatus?: string;
    card: {
        brand: string;
        card_type: string;
        last_digits: string;
        type: string;
    };
}

export interface HostedFieldsHandler {
    /**
     * Add a class to a field. Useful for updating field styles when events occur elsewhere in your checkout.
     */
    addClass: (field: string, className: string) => Promise<void>;
    /**
     * Clear the value of a field.
     */
    clear: (field: string) => Promise<void>;
    /**
     * Programmatically focus a field.
     */
    focus: (field: string) => Promise<void>;
    /**
     * Get supported card types configured in the Braintree Control Panel.
     */
    getCardTypes: () => HostedFieldsCardTypes;
    /**
     * Get the state of all the rendered fields.
     */
    getState: () => HostedFieldsState;
    /**
     * Removes a supported attribute from a field.
     */
    removeAttribute: (options: {
        field: string;
        attribute: string;
    }) => Promise<void>;
    /**
     * Removes a class to a field. Useful for updating field styles when events occur elsewhere in your checkout.
     */
    removeClass: (options: {
        field: string;
        className: string;
    }) => Promise<void>;
    /**
     * Sets an attribute of a field. Supported attributes are aria-invalid,
     * aria-required, disabled, and placeholder.
     */
    setAttribute: (options: {
        field: string;
        attribute: string;
        value: string;
    }) => Promise<void>;
    /**
     * Sets a visually hidden message (for screen readers) on a field.
     */
    setMessage: (options: { field: string; attribute: string }) => void;
    /**
     * Sets the month options for the expiration month field when presented as a select element.
     */
    setMonthOptions: (options: unknown) => Promise<void>;
    /**
     * Sets the placeholder from a field.
     */
    setPlaceholder: (field: string, placeholder: string) => Promise<void>;
    /**
     * Submit the form if is valid
     */
    submit: (
        options?: Record<string, unknown>
    ) => Promise<HostedFieldsSubmitResponse>;
    /**
     * Clean all the fields from the DOM
     */
    teardown: () => Promise<void>;
    /**
     * Tokenize fields and returns a nonce payload.
     */
    tokenize: (
        options: HostedFieldsTokenize
    ) => Promise<Record<string, unknown>>;

    on<EventType extends HostedFieldEventType>(
        event: EventType,
        handler: (event: HostedFieldsEventTypeMap[EventType]) => void
    ): void;
    off<EventType extends HostedFieldEventType>(
        event: EventType,
        handler: (event: HostedFieldsEventTypeMap[EventType]) => void
    ): void;
}

export interface PayPalHostedFieldsComponent {
    isEligible: () => boolean;
    render: (
        options: PayPalHostedFieldsComponentOptions
    ) => Promise<HostedFieldsHandler>;
}