export * from './BlikAlias';
export * from './BlikAliasResponse';
export * from './BlikFields';
export * from './BlikResponse';
export * from './CardsErrCode';
export * from './ChargebackStatus';
export * from './CheckFields';
export * from './CheckResponse';
export * from './CreateFields';
export * from './CreateResponse';
export * from './DeregisterFields';
export * from './GetFields';
export * from './GetResponse';
export * from './Language';
export * from './MasspaymentAuthorizeFields';
export * from './MasspaymentAuthorizeResponse';
export * from './MasspaymentCreateFields';
export * from './MasspaymentCreateResponse';
export * from './MasspaymentErrCode';
export * from './MasspaymentErrDesc';
export * from './MasspaymentPacksFields';
export * from './MasspaymentPacksResponse';
export * from './MasspaymentTransfersFields';
export * from './MasspaymentTransfersResponse';
export * from './Onetimer';
export * from './PacksObject';
export * from './PaymentAttempts';
export * from './PresaleFields';
export * from './RefundAnyFields';
export * from './RefundAnyResponse';
export * from './RefundFields';
export * from './RefundResponse';
export * from './RefundStatusResponse';
export * from './RefundTransactionFields';
export * from './RegisterSaleFields';
export * from './RegisterSaleResponse';
export * from './ReportFields';
export * from './ReportResponse';
export * from './Result';
export * from './SaleFields';
export * from './SaleResponse';
export * from './SecuresaleFields';
export * from './SecuresaleResponse';
export * from './TransactionErrorCodes';
export * from './TransfersObject';
export * from './VcFinishFields';
export * from './VcPrepareFields';
export * from './VcPrepareResponse';

import { BlikAlias , BlikAliasTypeEnum    } from './BlikAlias';
import { BlikAliasResponse } from './BlikAliasResponse';
import { BlikFields } from './BlikFields';
import { BlikResponse } from './BlikResponse';
import { CardsErrCode } from './CardsErrCode';
import { ChargebackStatus   , ChargebackStatusStatusEnum   } from './ChargebackStatus';
import { CheckFields } from './CheckFields';
import { CheckResponse } from './CheckResponse';
import { CreateFields            , CreateFieldsLanguageEnum            } from './CreateFields';
import { CreateResponse } from './CreateResponse';
import { DeregisterFields } from './DeregisterFields';
import { GetFields } from './GetFields';
import { GetResponse , GetResponseStatusEnum  , GetResponseErrorCodeEnum      , GetResponseTestModeEnum              } from './GetResponse';
import { Language } from './Language';
import { MasspaymentAuthorizeFields } from './MasspaymentAuthorizeFields';
import { MasspaymentAuthorizeResponse } from './MasspaymentAuthorizeResponse';
import { MasspaymentCreateFields } from './MasspaymentCreateFields';
import { MasspaymentCreateResponse } from './MasspaymentCreateResponse';
import { MasspaymentErrCode } from './MasspaymentErrCode';
import { MasspaymentErrDesc } from './MasspaymentErrDesc';
import { MasspaymentPacksFields } from './MasspaymentPacksFields';
import { MasspaymentPacksResponse } from './MasspaymentPacksResponse';
import { MasspaymentTransfersFields } from './MasspaymentTransfersFields';
import { MasspaymentTransfersResponse } from './MasspaymentTransfersResponse';
import { Onetimer } from './Onetimer';
import { PacksObject   , PacksObjectStatusEnum      } from './PacksObject';
import { PaymentAttempts , PaymentAttemptsPaymentErrorCodeEnum   } from './PaymentAttempts';
import { PresaleFields } from './PresaleFields';
import { RefundAnyFields } from './RefundAnyFields';
import { RefundAnyResponse } from './RefundAnyResponse';
import { RefundFields } from './RefundFields';
import { RefundResponse       , RefundResponseStatusEnum        } from './RefundResponse';
import { RefundStatusResponse } from './RefundStatusResponse';
import { RefundTransactionFields } from './RefundTransactionFields';
import { RegisterSaleFields } from './RegisterSaleFields';
import { RegisterSaleResponse } from './RegisterSaleResponse';
import { ReportFields } from './ReportFields';
import { ReportResponse } from './ReportResponse';
import { Result } from './Result';
import { SaleFields } from './SaleFields';
import { SaleResponse       , SaleResponseStatusEnum     } from './SaleResponse';
import { SecuresaleFields } from './SecuresaleFields';
import { SecuresaleResponse        , SecuresaleResponseStatusEnum        } from './SecuresaleResponse';
import { TransactionErrorCodes } from './TransactionErrorCodes';
import { TransfersObject   , TransfersObjectStatusEnum            } from './TransfersObject';
import { VcFinishFields } from './VcFinishFields';
import { VcPrepareFields } from './VcPrepareFields';
import { VcPrepareResponse } from './VcPrepareResponse';

/* tslint:disable:no-unused-variable */
let primitives = [
                    "string",
                    "boolean",
                    "double",
                    "integer",
                    "long",
                    "float",
                    "number",
                    "any"
                 ];

const supportedMediaTypes: { [mediaType: string]: number } = {
  "application/json": Infinity,
  "application/octet-stream": 0
}

                 
let enumsMap: Set<string> = new Set<string>([
    "BlikAliasTypeEnum",
    "CardsErrCode",
    "ChargebackStatusStatusEnum",
    "CreateFieldsLanguageEnum",
    "GetResponseStatusEnum",
    "GetResponseErrorCodeEnum",
    "GetResponseTestModeEnum",
    "Language",
    "MasspaymentErrCode",
    "MasspaymentErrDesc",
    "Onetimer",
    "PacksObjectStatusEnum",
    "PaymentAttemptsPaymentErrorCodeEnum",
    "RefundResponseStatusEnum",
    "Result",
    "SaleResponseStatusEnum",
    "SecuresaleResponseStatusEnum",
    "TransactionErrorCodes",
    "TransfersObjectStatusEnum",
]);

let typeMap: {[index: string]: any} = {
    "BlikAlias": BlikAlias,
    "BlikAliasResponse": BlikAliasResponse,
    "BlikFields": BlikFields,
    "BlikResponse": BlikResponse,
    "ChargebackStatus": ChargebackStatus,
    "CheckFields": CheckFields,
    "CheckResponse": CheckResponse,
    "CreateFields": CreateFields,
    "CreateResponse": CreateResponse,
    "DeregisterFields": DeregisterFields,
    "GetFields": GetFields,
    "GetResponse": GetResponse,
    "MasspaymentAuthorizeFields": MasspaymentAuthorizeFields,
    "MasspaymentAuthorizeResponse": MasspaymentAuthorizeResponse,
    "MasspaymentCreateFields": MasspaymentCreateFields,
    "MasspaymentCreateResponse": MasspaymentCreateResponse,
    "MasspaymentPacksFields": MasspaymentPacksFields,
    "MasspaymentPacksResponse": MasspaymentPacksResponse,
    "MasspaymentTransfersFields": MasspaymentTransfersFields,
    "MasspaymentTransfersResponse": MasspaymentTransfersResponse,
    "PacksObject": PacksObject,
    "PaymentAttempts": PaymentAttempts,
    "PresaleFields": PresaleFields,
    "RefundAnyFields": RefundAnyFields,
    "RefundAnyResponse": RefundAnyResponse,
    "RefundFields": RefundFields,
    "RefundResponse": RefundResponse,
    "RefundStatusResponse": RefundStatusResponse,
    "RefundTransactionFields": RefundTransactionFields,
    "RegisterSaleFields": RegisterSaleFields,
    "RegisterSaleResponse": RegisterSaleResponse,
    "ReportFields": ReportFields,
    "ReportResponse": ReportResponse,
    "SaleFields": SaleFields,
    "SaleResponse": SaleResponse,
    "SecuresaleFields": SecuresaleFields,
    "SecuresaleResponse": SecuresaleResponse,
    "TransfersObject": TransfersObject,
    "VcFinishFields": VcFinishFields,
    "VcPrepareFields": VcPrepareFields,
    "VcPrepareResponse": VcPrepareResponse,
}

export class ObjectSerializer {
    public static findCorrectType(data: any, expectedType: string) {
        if (data == undefined) {
            return expectedType;
        } else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
            return expectedType;
        } else if (expectedType === "Date") {
            return expectedType;
        } else {
            if (enumsMap.has(expectedType)) {
                return expectedType;
            }

            if (!typeMap[expectedType]) {
                return expectedType; // w/e we don't know the type
            }

            // Check the discriminator
            let discriminatorProperty = typeMap[expectedType].discriminator;
            if (discriminatorProperty == null) {
                return expectedType; // the type does not have a discriminator. use it.
            } else {
                if (data[discriminatorProperty]) {
                    var discriminatorType = data[discriminatorProperty];
                    if(typeMap[discriminatorType]){
                        return discriminatorType; // use the type given in the discriminator
                    } else {
                        return expectedType; // discriminator did not map to a type
                    }
                } else {
                    return expectedType; // discriminator was not present (or an empty string)
                }
            }
        }
    }

    public static serialize(data: any, type: string, format: string) {
        if (data == undefined) {
            return data;
        } else if (primitives.indexOf(type.toLowerCase()) !== -1) {
            return data;
        } else if (type.lastIndexOf("Array<", 0) === 0) { // string.startsWith pre es6
            let subType: string = type.replace("Array<", ""); // Array<Type> => Type>
            subType = subType.substring(0, subType.length - 1); // Type> => Type
            let transformedData: any[] = [];
            for (let index in data) {
                let date = data[index];
                transformedData.push(ObjectSerializer.serialize(date, subType, format));
            }
            return transformedData;
        } else if (type === "Date") {
            if (format == "date") {
                let month = data.getMonth()+1
                month = month < 10 ? "0" + month.toString() : month.toString()
                let day = data.getDate();
                day = day < 10 ? "0" + day.toString() : day.toString();

                return data.getFullYear() + "-" + month + "-" + day;
            } else {
                return data.toISOString();
            }
        } else {
            if (enumsMap.has(type)) {
                return data;
            }
            if (!typeMap[type]) { // in case we dont know the type
                return data;
            }
            
            // Get the actual type of this object
            type = this.findCorrectType(data, type);

            // get the map for the correct type.
            let attributeTypes = typeMap[type].getAttributeTypeMap();
            let instance: {[index: string]: any} = {};
            for (let index in attributeTypes) {
                let attributeType = attributeTypes[index];
                instance[attributeType.baseName] = ObjectSerializer.serialize(data[attributeType.name], attributeType.type, attributeType.format);
            }
            return instance;
        }
    }

    public static deserialize(data: any, type: string, format: string) {
        // polymorphism may change the actual type.
        type = ObjectSerializer.findCorrectType(data, type);
        if (data == undefined) {
            return data;
        } else if (primitives.indexOf(type.toLowerCase()) !== -1) {
            return data;
        } else if (type.lastIndexOf("Array<", 0) === 0) { // string.startsWith pre es6
            let subType: string = type.replace("Array<", ""); // Array<Type> => Type>
            subType = subType.substring(0, subType.length - 1); // Type> => Type
            let transformedData: any[] = [];
            for (let index in data) {
                let date = data[index];
                transformedData.push(ObjectSerializer.deserialize(date, subType, format));
            }
            return transformedData;
        } else if (type === "Date") {
            return new Date(data);
        } else {
            if (enumsMap.has(type)) {// is Enum
                return data;
            }

            if (!typeMap[type]) { // dont know the type
                return data;
            }
            let instance = new typeMap[type]();
            let attributeTypes = typeMap[type].getAttributeTypeMap();
            for (let index in attributeTypes) {
                let attributeType = attributeTypes[index];
                instance[attributeType.name] = ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type, attributeType.format);
            }
            return instance;
        }
    }


    /**
     * Normalize media type
     *
     * We currently do not handle any media types attributes, i.e. anything
     * after a semicolon. All content is assumed to be UTF-8 compatible.
     */
    public static normalizeMediaType(mediaType: string | undefined): string | undefined {
        if (mediaType === undefined) {
            return undefined;
        }
        return mediaType.split(";")[0].trim().toLowerCase();
    }

    /**
     * From a list of possible media types, choose the one we can handle best.
     *
     * The order of the given media types does not have any impact on the choice
     * made.
     */
    public static getPreferredMediaType(mediaTypes: Array<string>): string {
        /** According to OAS 3 we should default to json */
        if (!mediaTypes) {
            return "application/json";
        }

        const normalMediaTypes = mediaTypes.map(this.normalizeMediaType);
        let selectedMediaType: string | undefined = undefined;
        let selectedRank: number = -Infinity;
        for (const mediaType of normalMediaTypes) {
            if (supportedMediaTypes[mediaType!] > selectedRank) {
                selectedMediaType = mediaType;
                selectedRank = supportedMediaTypes[mediaType!];
            }
        }

        if (selectedMediaType === undefined) {
            throw new Error("None of the given media types are supported: " + mediaTypes.join(", "));
        }

        return selectedMediaType!;
    }

    /**
     * Convert data to a string according the given media type
     */
    public static stringify(data: any, mediaType: string): string {
        if (mediaType === "application/json") {
            return JSON.stringify(data);
        }

        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.stringify.");
    }

    /**
     * Parse data from a string according to the given media type
     */
    public static parse(rawData: string, mediaType: string | undefined) {
        if (mediaType === undefined) {
            throw new Error("Cannot parse content. No Content-Type defined.");
        }

        if (mediaType === "application/json") {
            return JSON.parse(rawData);
        }

        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.parse.");
    }
}