/**
 * Bleumi Pay REST API
 * A simple and powerful REST API to integrate ERC-20, Ethereum, xDai, Algorand payments and/or payouts into your business or application
 *
 * The version of the OpenAPI document: 1.0.0
 * Contact: info@bleumi.com
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */

import { Chain } from '../model/chain';
import { PaymentRefundRequest } from '../model/paymentRefundRequest';
import { PaymentSettleRequest } from '../model/paymentSettleRequest';
import { CreateCheckoutUrlRequest } from '../model/createCheckoutUrlRequest';
import { ValidateCheckoutRequest } from '../model/validateCheckoutRequest';
import { CreatePayoutRequest } from '../model/createPayoutRequest';

export class RequestValidator {

    public static isEmpty(str) {
        return (!str || 0 === str.length || (typeof str === 'undefined') );
    }

    // IsEthAddress returns true if input is a valid Ethereum address.
    public static IsEthAddress(addr: string) {
        var regex = /^0x[a-fA-F0-9]{40}$/
        if ((regex.test(addr)||(addr=="ETH")||(addr=="XDAI")||(addr=="XDAIT"))) {
            return true;
        }
        return false;
    }

    // IsRskAddress returns true if input is a valid RSK address.
    public static IsRskAddress(addr: string) {
        var regex = /^0x[a-fA-F0-9]{40}$/
        if ((regex.test(addr)||(addr=="RBTC"))) {
            return true;
        }
        return false;
    }

    // IsAlgoAddress returns true if input is a valid Algorand address.
    public static IsAlgoAddress(addr: string) {
        var regex = /^[A-Z2-7+=*]{58}$/
        if (regex.test(addr)) {
            return true;
        }
        return false;
    }

    // IsAlgoAddress returns true if input is a valid Algorand address.
    public static IsAlgoToken(addr: string) {
        var regex = /^[0-9]*$/
        if (regex.test(addr)||(addr=="ALGO")) {
            return true;
        }
        return false;
    }    

    // CheckEthAddr is a Validator for Ethereum address.
    public static CheckEthAddr(name: string, input: string) {
        var msg = "";
        if (!this.IsEthAddress(input)) {
            msg = "'" + name + "' is not a valid Ethereum address";
        }
        return msg;
    }

    // CheckRskAddr is a Validator for RSK address.
    public static CheckRskAddr(name: string, input: string) {
        var msg = "";
        if (!this.IsEthAddress(input)) {
            msg = "'" + name + "' is not a valid RSK address";
        }
        return msg;
    }

    // CheckAlgoAddr is a Validator for Algorand tokens.
    public static CheckAlgoAddr(name: string, input: string, isToken: boolean) {
        var msg = "";
        if (isToken) {
            if (!this.IsAlgoToken(input) ) {
                msg = "'" + name + "' is not a valid Algorand token";
            }
        } else {
            if (!this.IsAlgoAddress(input) ) {
                msg = "'" + name + "' is not a valid Algorand address";
            }
        }
        return msg;
    }

    // IsAlgoNetwork returns true if the chain is Algorand
    public static IsAlgoNetwork(value: string) {
        return ((value == "alg_mainnet") || (value == "alg_testnet"))
    }

    // IsRskNetwork returns true if the chain is RSK
    public static IsRskNetwork(value: string) {
        return ((value == "rsk") || (value == "rsk_testnet"))
    }

    // CheckRequiredParam is a Validator for verify whether a required parameter is missing
    public static CheckRequiredParam(name: string, input: string) {
        var msg = "";
        if (this.isEmpty(input)) {
            msg = "Missing required parameter '" + name + "'";
        }
        return msg;
    }

    // CheckNetworkAddr is a Validator for any network tokens.
    public static CheckNetworkAddr(name: string, input: string, chain: string, mandatory: boolean, isToken: boolean) {
        var msg = "";
        if (mandatory) {
            msg = this.CheckRequiredParam(name, input);
            if (!this.isEmpty(msg)) {
                return msg;
            }
        }
        if (!this.isEmpty(input)) {
            if (this.IsAlgoNetwork(chain)) {
                msg = this.CheckAlgoAddr(name, input, isToken)
            } else if (this.IsRskNetwork(chain)) {
                msg = this.CheckRskAddr(name, input)
            } else {
                msg = this.CheckEthAddr(name, input)
            }
        }
        return msg;
    }

    // ValidateRefundPayment - checks if refundPayment parameters are valid
    public static ValidateRefundPayment(params: PaymentRefundRequest, chain?: Chain) {
        var msg = "";
        var networkChain;
        if (typeof chain !== 'undefined') {
            networkChain = String(chain);
        }
        msg = this.CheckNetworkAddr("Token", params.token, networkChain , true, true);
        return msg;
    }

    // ValidateSettlePayment - checks if settlePayment parameters are valid
    public static ValidateSettlePayment(params: PaymentSettleRequest, chain?: Chain) {
        
        var msg = "";
        
        var networkChain;
        if (typeof chain !== 'undefined') {
            networkChain = String(chain);
        }

        msg = this.CheckRequiredParam("Chain", networkChain);
            if (!this.isEmpty(msg)) {
                return msg;
            }
       
        msg = this.CheckNetworkAddr("Token", params.token, networkChain , true, true);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        msg = this.CheckRequiredParam("Amount", params.amount);
        return msg;
    }

    // ValidateCreateCheckoutURL - checks if createCheckoutUrl parameters are valid
    public static ValidateCreateCheckoutURL(params: CreateCheckoutUrlRequest) {
        
        var msg = "";
        
        msg = this.CheckRequiredParam("Id", params.id);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        msg = this.CheckRequiredParam("Currency", params.currency);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        msg = this.CheckRequiredParam("Amount", params.amount);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        msg = this.CheckRequiredParam("CancelUrl", params.cancelUrl);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        msg = this.CheckRequiredParam("SuccessUrl", params.successUrl);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        var token;
        if (typeof params.chain !== 'undefined') {
            token = String(params.token);
        }
        
        if (!this.isEmpty(token)) {
            
            var networkChain;
            if (typeof params.chain !== 'undefined') {
                networkChain = String(params.chain);
            }
            
            msg = this.CheckRequiredParam("Chain", networkChain);
            if (!this.isEmpty(msg)) {
                return msg;
            }

            msg = this.CheckNetworkAddr("token", String(params.token), networkChain , false, true);
            if (!this.isEmpty(msg)) {
                return msg;
            }

            var transferAddress;
            if (typeof params.transferAddress !== 'undefined') {
                transferAddress = String(params.transferAddress);
            }
            
            if (!this.isEmpty(transferAddress)) {
                msg = this.CheckNetworkAddr("transferAddress", transferAddress, networkChain , false, false);
                if (!this.isEmpty(msg)) {
                    return msg;
                }
            }
        }
        return msg;
    }

    // ValidateCheckoutPaymentParams - checks if ValidateCheckoutPayment parameters are valid
    public static ValidateCheckoutPaymentParams(params: ValidateCheckoutRequest) {
        var msg = "";
        msg = this.CheckRequiredParam("HmacAlg", params.hmacAlg);
        if (!this.isEmpty(msg)) {
            return msg;
        }
        msg = this.CheckRequiredParam("HmacInput", params.hmacInput);
        if (!this.isEmpty(msg)) {
            return msg;
        }
        msg = this.CheckRequiredParam("HmacKeyId", params.hmacKeyId);
        if (!this.isEmpty(msg)) {
            return msg;
        }
        msg = this.CheckRequiredParam("HmacValue", params.hmacValue);
        return msg;
    }

    // ValidateCreatePayout - checks if createPayout parameters are valid
    public static ValidateCreatePayout(params: CreatePayoutRequest, chain?: Chain) {
        var msg = "";
        var networkChain;
        if (typeof chain !== 'undefined') {
            networkChain = String(chain);
        }

        //Check if 'txid' is provided
        msg = this.CheckRequiredParam("TxId", params.txid);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        msg = this.CheckRequiredParam("Chain", networkChain);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        //Check if 'Token' is valid network address.
        msg = this.CheckNetworkAddr("Token", params.token, networkChain, true, true);
        if (!this.isEmpty(msg)) {
            return msg;
        }

        //Check if 'Payouts' array is defined.
        var payouts = params.payouts;

        //Check if 'Payouts' array contains at least 1 payout defined
        if (payouts.length == 0) {
            return "Payouts not defined."
        }

        var i, len;
        for (i = 0, len = payouts.length; i < len; ++i) {
            
            //Check if for given payout, 'TransferAddress' is provided 
            msg = this.CheckNetworkAddr("TransferAddress", payouts[i].transferAddress, networkChain, true, false);
            if (!this.isEmpty(msg)) {
                return msg;
            }

            //Check if for given payout, 'Amount' is provided 
            msg = this.CheckRequiredParam("Amount", payouts[i].amount);
            if (!this.isEmpty(msg)) {
                return msg;
            }

            //For Algorand payouts, check if for given payout, 'Authorization' is provided 
            if (this.IsAlgoNetwork(networkChain)) {
                var auth; 
                if (typeof payouts[i].authorization !== 'undefined') {
                    auth = String(payouts[i].authorization)
                }
                msg = this.CheckRequiredParam("Authorization", auth);
                if (!this.isEmpty(msg)) {
                    return msg;
                }
            }
        }
        return msg;
    }

}