import {BasicCustomerInstance, CustomerParams} from '../Controller';
import {compileExpressionString, isExpression} from '../../../util/vm';
import {request} from '../../../services/api';
import {notification} from '@native-ads/antd';
import * as _ from 'lodash';
import {parseExpressString} from '../../../parser/index';

export interface SubmitCustomerExecConfig {
    /**
     * 提交的地址
     */
    url: string;

    /**
     * 提交的方式
     */
    method: string;

    /**
     * 提交的数据
     */
    data: Object | string;

    /**
     * 返回值验证
     */
    retCheckPattern?: string;

    /**
     * 返回值映射
     */
    retMapping?: Object;

    /**
     * 提示的错误信息
     */
    retErrorMsg?: string;
    retErrMsg?: string;

    /**
     * 返回值映射的字段
     */
    namespace?: string;
}

export class SubmitCustomer implements BasicCustomerInstance {
    async exec(config: SubmitCustomerExecConfig, params: CustomerParams) {
        if (!config.url) {
            console.error('URL is Required for submit request');
            return;
        }

        if (!config.method) {
            config.method = 'GET';
        }

        let {
            runTime
        } = params;

        config = compileExpressionString(config, runTime, ['retCheckPattern', 'retErrorMsg']);

        let data = config.data;

        if (_.isPlainObject(data)) {
            config.data = compileExpressionString(data, runTime);
        } else if (typeof data === 'string' && isExpression(data)) {
            config.data = parseExpressString(data, runTime);
        }

        let proxyUrl = null;

        if (runTime.$global) {
            proxyUrl = runTime.$global.proxy;
        }

        let ret = await request(config.url, config, proxyUrl);

        if (ret.status !== 200) {
            console.error('Request Failed', ret.statusText);
            return;
        }

        if (config.retCheckPattern) {
            let isValid = parseExpressString(config.retCheckPattern, {
                ...runTime,
                $output: ret.data
            });

            if (!isValid) {
                console.error('submit response value is not valid', ret.data);
                let errmsg = config.retErrorMsg || config.retErrMsg;
                if (errmsg && isExpression(errmsg)) {
                    errmsg = parseExpressString(errmsg, {
                        ...runTime,
                        $output: ret.data
                    });
                }

                notification.error({
                    message: '提交失败',
                    description: errmsg
                });

                return;
            }
        }

        if (_.isPlainObject(config.retMapping)) {
            let innerRunTime = {
                ...runTime,
                $output: ret.data
            };

            ret.data = compileExpressionString(config.retMapping, innerRunTime)!;
        }

        return ret.data;
    }
}