'use strict';


const api = global.yoho.API;
const serviceApi = global.yoho.ServiceAPI;

const _ = require('lodash');

// const config = global.yoho.config;
const helpers = global.yoho.helpers;
const camelCase = global.yoho.camelCase;
const logger = global.yoho.logger;
const stringProcess = require(`${global.utils}/string-process`);

const CODE_LOGISTIC_BANNER = '1fc9b2484fcd559049f2f7e0db313f20'; // 物流详情banner资源码

const closeReasons = () => {
    return api.get('', {
        method: 'app.SpaceOrders.closeReasons'
    }, {
        cache: true
    }).then((result) => {
        if (result && result.code === 200) {
            return result.data;
        } else {
            return {};
        }
    });
};

/**
 * 获取快递有关信息
 * @private
 */
const _assignExpressInfo = (showLogistics, order) => {
    let data = {};

    if (showLogistics && order.expressCompany && order.expressCompany.caption) {
        data = {
            logisticsUrl: helpers.urlFormat('/home/logistic', {order_code: order.orderCode}),
            logisticsCompany: order.expressCompany.caption,
            logisticsNum: order.expressNumber || ''
        };
    }

    return data;
};

/**
 * 获取订单状态
 * @private
 */
const _getOrderStatus = (order, showLogistics) => {
    let orderBtn = [];

    if (!order) {
        return {};
    }

    let attribute = _.parseInt(order.attribute);

    if (attribute === 9 || attribute === 11) {
        /* 预售商品，不能进行任何操作 */
        orderBtn.push({
            isAdvance: true
        });
        return {orderBtn: orderBtn};
    }

    /* 倒计时时间 订单详情页倒计时不在同一级*/
    if (order.counterFlag === 'Y' && parseInt(order.payLefttime, 10)) {
        orderBtn.push({
            leftTimeTop: order.payLefttime * 1000
        });
    }

    _.each(order.links, function(val) {
        switch (val) {
            case 'refundApply':// 申请退款
                orderBtn.push({
                    refundApply: true
                });
                break;
            case 'modifyAddress':// 修改收货地址
                orderBtn.push({
                    modifyAddress: true,
                    link: helpers.urlFormat('/home/orders/addressModify', {
                        relation: order.relateOrderCode === 'Y', // 判断是否有关联订单
                        orderCode: order.orderCode,
                        areaCode: _.get(order, 'deliveryAddress.areaCode', ''),
                        provinceAreaCode: order.isSupportChangeProvince !== 'Y' &&
                            _.get(order, 'deliveryAddress.provinceAreaCode', '') || ''// 如果不允许修改省
                    })
                });
                break;
            case 'buyNow':// 立即付款
                orderBtn.push({
                    buyNow: true,
                    link: helpers.urlFormat('/home/orders/paynew', {order_code: order.orderCode}),
                });
                break;
            case 'closeOrder':// 取消订单
                orderBtn.push({
                    closeOrder: true
                });
                break;
            case 'confirm':// 订单确认
                orderBtn.push({
                    confirm: true
                });
                break;
            case 'getExpress':// 查看物流
                orderBtn.push(Object.assign(
                    {getExpress: true},
                    _assignExpressInfo(showLogistics, order)
                ));
                break;
            case 'shareOrder':// 晒单评价
                break;
            case 'delOrder':// 删除订单
                orderBtn.push({
                    delOrder: true,
                });
                break;
            case 'lookQrcode':// 查看二维码
                orderBtn.push({
                    lookQrcode: true,
                    link: helpers.urlFormat(`/home/QRcode/${order.orderCode}`),
                });
                break;
            case 'afterService':// 售后服务
                orderBtn.push({
                    afterService: true
                });
                break;
            case 'readd':// 再次购买
                orderBtn.push({
                    readd: true
                });
                break;
            default:
                break;
        }
    });

    return {orderBtn: orderBtn};
};


const orderDetailData = (uid, orderCode) => {

    if (!uid || !orderCode || !stringProcess.isNumeric(orderCode)) {
        return Promise.resolve({});
    }

    return api.get('', {
        method: 'app.SpaceOrders.detail',
        uid: uid,
        order_code: orderCode
    }).then(result => {
        if (result && result.code === 200) {
            let orderDetail = camelCase(result.data);
            let goods = [];
            let status = _getOrderStatus(orderDetail, true);
            let offlinestore; // 线下店订单
            let deliveryOffline; // 门店取货

            orderDetail = _.assign(orderDetail, status);

            if (parseInt(orderDetail.attribute, 10) === 3) {
                orderDetail = _.assign(orderDetail, {
                    isVirtual: true,
                    mobile: result.data.mobile
                });
            }

            orderDetail = _.assign(orderDetail, {
                addressAll: orderDetail.area + orderDetail.address
            });

            _.forEach(orderDetail.orderGoods, function(data) {
                let obj = {};
                let count = +data.buyNumber;

                obj = _.assign(obj, {
                    thumb: data.goodsImage,
                    name: data.productName,
                    color: data.factoryColorName ? data.factoryColorName : data.colorName,
                    size: data.sizeName,
                    payPrice: data.realPayPrice,
                    salePrice: parseFloat(data.salesPrice).toFixed(2),
                    count: count,
                    tickets: data.goodsType === 'ticket'

                    // isVipPrice: data.discountTag === 'V',
                    // isStudebt: data.discountTag === 'S'
                });

                if (parseInt(data.realPayPrice, 10) === parseInt(data.salesPrice, 10)) {
                    obj.salePrice = false;
                }

                if (data.goodsType === 'gift') {
                    obj = _.assign(obj, {
                        gift: true,
                        salePrice: parseFloat(data.salesPrice).toFixed(2),
                        payPrice: data.goodsPrice
                    });
                } else if (data.goodsType === 'price_gift') {
                    obj = _.assign(obj, {
                        advanceBuy: true,
                        salePrice: parseFloat(data.salesPrice).toFixed(2),
                        payPrice: data.goodsPrice
                    });
                }

                if (data.expectArrivalTime) {
                    obj = _.assign(obj, {
                        appearDate: data.expectArrivalTime
                    });
                }

                if (data.productSkn) {
                    obj = _.assign(obj, {
                        link: '/product/' + data.productSkn + '.html' // 商品url改版
                    });
                }

                if (data.goodsType === 'ticket') {
                    obj = _.assign(obj, {
                        tickets: true
                    });
                }

                goods.push(obj);

                orderDetail = _.assign(orderDetail, {
                    orderCount: count
                });

            });

            orderDetail.goods = goods;

            // 为支付的拆单配送信息
            if (orderDetail.isMultiPackage === 'Y') {
                orderDetail = _.assign(orderDetail, {
                    jitDetailUrl: helpers.urlFormat('/cart/index/new/jitDetail', {orderCode: orderCode})
                });
            }

            if (parseInt(orderDetail.paymentType, 10) !== 2) {
                if (_.get(orderDetail, 'isOfflineshops', 'N') === 'Y') {

                    offlinestore = orderDetail.offlineStore !== '' ? orderDetail.offlineStore : false;
                    deliveryOffline = _.get(orderDetail, 'isDeliveryOffline', 'N') === 'Y' ? true : false;
                } else {

                    offlinestore = false;
                    deliveryOffline = false;
                }

                orderDetail = _.assign(orderDetail, {
                    offlinestore: offlinestore,
                    deliveryOffline: deliveryOffline
                });
            } else {
                orderDetail.paymentName = orderDetail.paymentName !== '' ? orderDetail.paymentName : '货到付款';
            }

            if (orderDetail.invoice) {
                orderDetail.invoice.type = (orderDetail.invoice.type + '' === '2');
            }

            if (_.get(result, 'data.isSupportRefund', 'N') === 'Y') {
                orderDetail.refundUrl = helpers.urlFormat('/home/return/refund', {orderCode: orderCode});
            }

            if (_.get(result, 'data.isSupportExchange', 'N') === 'Y') {
                orderDetail.changeUrl = helpers.urlFormat('/home/return/exchange', {orderCode: orderCode});
            }

            orderDetail.imUrl = helpers.urlFormat('/service/chatQaList');

            return orderDetail;
        } else {
            logger.error('detail info return no 200');
            return {};
        }

    });
};

// 删除订单
const delOrder = (orderCode, uid) => {
    return api.get('', {
        method: 'app.SpaceOrders.delOrderByCode',
        uid: uid,
        order_code: orderCode
    });
};

// 再次购买
const readdData = (orderCode, uid) => {
    return api.get('', {
        method: 'app.Shopping.readd',
        uid: uid,
        order_code: orderCode
    }).then((result) => {
        if (result && result.code === 200) {
            result.message = '商品已重新加入购物车';
        } else if (result.code === '400') {
            result.message = '缺失参数';
        } else {
            result.message = '商品加入购物车失败';
            result.datat = {};
        }

        return result;
    });
};

// 取消订单
const cancelOrder = (orderCode, uid, reasonId, gender, channel, reason) => {


    return api.get('', {
        method: 'app.SpaceOrders.close',
        uid: uid,
        order_code: orderCode,
        reasonId: reasonId,
        reasons: reason,
        gender: gender,
        yh_channel: channel
    });
};

/**
 * 申请退款
 */
const refundApply = (params) => {
    return api.get('', {
        method: 'app.SpaceOrders.refundApply',
        uid: params.uid,
        order_code: params.orderCode,
        reason_id: params.reasonId,
        reason: params.reason
    });
};

/*
* 我的订单-查看物流
* @param int $orderCode 订单号
* @param int $uid 用户ID
* @return array
*/
const _logisticsData = (params) => {
    let finalParams = {
        order_code: params.order_code,
        uid: params.uid
    };

    finalParams.method = 'app.express.li';

    // 退换货物流
    if (params.type === 'refund' || params.type === 'change') {
        _.assign(finalParams, {
            method: 'app.express.getNewExpress',
            id: params.id,
            type: params.type
        });
    } else {
        _.assign(finalParams, {
            method: 'app.express.li'
        });
    }

    return api.get('', finalParams);
};

/**
 * 获取物流详情页banner
 */
const _getLogisterBanner = () => {
    return serviceApi.get('operations/api/v5/resource/get', {
        content_code: CODE_LOGISTIC_BANNER
    }, {code: 200});
};

/**
 * 查看物流
 *
 * @param int orderCode 订单编号
 * @param int uid 用户ID
 * @return array
 */
const logistics = (params) => {
    return Promise.all([
        _getLogisterBanner(),
        _logisticsData(params),
    ]).then(result => {
        let finalResult = {
            banner: []
        };
        let banners = result[0];
        let logistic = result[1];

        // 获取物流详情页banner
        if (banners && banners.data) {
            _.forEach(banners.data, value => {
                _.forEach(value.data, subValue => {
                    finalResult.banner.push({
                        url: subValue.url,
                        img: subValue.src
                    });
                });
            });
        }

        if (logistic && logistic.data) {
            finalResult.logisticUrl = _.get(logistic, 'data.url', '');
            finalResult.logisticImg = _.get(logistic, 'data.logo', '');
            finalResult.logisticCompany = _.get(logistic, 'data.caption', '');
            finalResult.logisticNumber = _.get(logistic, 'data.express_number', '');
            finalResult.logisticDetail = [];

            _.forEach(_.get(logistic, 'data.express_detail', []), value => {
                finalResult.logisticDetail.push({
                    status: value.accept_address,
                    date: value.acceptTime,
                });
            });

        }

        return finalResult;
    });
};

/**
 * 修改订单地址
 * @param {参数} params
 */
const changeAddress = (params) => {
    let apiParams = {
        method: 'app.SpaceOrders.updateDeliveryAddress',
        order_code: params.orderCode,
        uid: params.uid,
        user_name: params.username,
        area_code: params.areaCode,
        address: params.address,
        mobile: params.mobile,
        udid: params.udid
    };

    if (params.addressId) {
        Object.assign(apiParams, {
            address_id: params.addressId
        });
    }

    if (params.phone) {
        Object.assign(apiParams, {
            phone: params.phone
        });
    }

    return api.post('', apiParams);
};

module.exports = {
    orderDetailData,
    closeReasons,
    delOrder,
    readdData,
    cancelOrder,
    refundApply,
    logistics,
    changeAddress
};