import {
    BasicAsyncProviderInterface,
    ProviderGlobalOptions,
    ProviderSourceConfig
} from '../Controller';
import {AxiosRequestConfig, AxiosResponse} from 'axios';
import {ContainerProps, getRuntimeContext} from '../../Container/types';
import {request} from '../../../services/api';
import {isNil, isPlainObject} from 'lodash';
import {compileExpressionString, isExpression} from '../../../util/vm';
import {parseExpressString} from '../../../parser/index';
import {notification} from '@native-ads/antd';

export interface AjaxProviderSourceConfig extends ProviderSourceConfig {
    config: AxiosRequestConfig;
}

export class AjaxDataProvider implements BasicAsyncProviderInterface {
    configCheck(provider: AjaxProviderSourceConfig) {
        if (!provider || !provider.config) {
            console.error('initialLoad Config is required for ajax call');
            return false;
        }

        let config = provider.config;

        if (!config.url) {
            console.error('url is required param for ajax call');
            return false;
        }

        return true;
    }

    parse(provider: AjaxProviderSourceConfig, props: ContainerProps, context: any) {
        let runTime = getRuntimeContext(props, context);
        provider.config = compileExpressionString(provider.config, runTime, [], true);

        for (let key in provider.config.data) {
            if (isNil(provider.config.data[key]) || provider.config.data[key] === '') {
                delete provider.config.data[key];
            }
        }

        return provider;
    }

    retCheck(ret: Object, provider: AjaxProviderSourceConfig, props: ContainerProps, context: any) {
        let pattern = provider.retCheckPattern;
        if (!pattern || !isExpression(pattern)) {
            return !isNil(ret);
        }

        let runTime = getRuntimeContext(props, context);
        return !!parseExpressString(pattern, {
            ...runTime,
            $output: ret
        });
    }

    retParse(ret: Object, provider: ProviderSourceConfig, props: ContainerProps, context: any) {
        let retMapping = provider.retMapping;

        if (!retMapping || !isPlainObject(retMapping)) {
            return ret;
        }

        let runTime = getRuntimeContext(props, context);
        return compileExpressionString(retMapping, {
            ...runTime,
            $output: ret
        });
    }

    async run(provider: AjaxProviderSourceConfig, options: ProviderGlobalOptions = {}) {
        let requestConfig: AxiosRequestConfig = provider.config;
        let response: AxiosResponse = await request(requestConfig.url!, requestConfig, options.proxy);
        return response.data;
    }

    onError(errmsg: string) {
        notification.error({
            message: '数据获取失败',
            description: errmsg
        });
    }
}