'use strict';

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资源码

module.exports = class extends global.yoho.BaseModel {
    constructor(ctx) {
        super(ctx);
    }

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

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

        data = {
            logisticsUrl: helpers.urlFormat('/home/logistic', {order_code: order.orderCode})
        };

        return data;
    }

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

        if (!order) {
            return {};
        }

        let attribute = _.parseInt(_.get(order, 'orderExtInfo.attribute'));

        order = _.assign(order, {
            orderCode: _.get(order, 'orderExtInfo.orderCode')
        });

        if (attribute === 9 || attribute === 11) {
            // 定金预售拼接提示语
            let countTime = 0;
            let payAmount = 0;

            if (_.get(order, 'orderDetailInfo.ext.payLefttime') &&
            parseInt(order.orderDetailInfo.ext.payLefttime, 10)) {
                countTime = order.orderDetailInfo.ext.payLefttime * 1000;
            }

            if (_.get(order, 'orderDetailInfo.key') === '203') { // 待支付尾款
                payAmount = _.get(order, 'orderExtInfo.orderTailPayAmount');
                order.orderDetailInfo.ext.desc = `你的商品已到货，您还需支付尾款<span>¥${payAmount}</span>，
                请在<i class="hours new-hours hide">${countTime}</i>内完成支付，超时订单自动取消`;
            } else if (_.get(order, 'orderDetailInfo.key') === '201') { // 待支付定金
                payAmount = _.get(order, 'orderExtInfo.orderDepositAmount');
                order.orderDetailInfo.ext.desc = `您需支付定金<span>¥${payAmount}</span>，
                请在<i class="hours new-hours hide">${countTime}</i>内完成支付，超时订单自动取消`;
            }

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

        /* 倒计时时间 订单详情页倒计时不在同一级*/
        if (_.get(order, 'orderDetailInfo.ext.payLefttime') && parseInt(order.orderDetailInfo.ext.payLefttime, 10)) {
            let countTime = _.get(order, 'orderDetailInfo.ext.payLefttime') * 1000;

            order.orderDetailInfo.ext.desc = `您的订单已提交，
            请在<i class="hours new-hours hide">${countTime}</i>内完成支付，超时订单自动取消`;
        }

        _.each(order.links, (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, 'deliveryInfo.deliveryAddress.areaCode', ''),
                            provinceAreaCode: _.get(order, 'deliveryInfo.isSupportChangeProvince') !== 'Y' &&
                                _.get(order, 'deliveryInfo.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},
                        this._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};
    }

    orderDetailData(uid, orderCode) {

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

        return this.get({
            data: {
                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 = this._getOrderStatus(orderDetail, true);
                let offlinestore; // 线下店订单
                let deliveryOffline; // 门店取货

                orderDetail = _.assign(orderDetail, status, {orderCode: orderCode});

                if (parseInt(_.get(orderDetail, 'orderExtInfo.attribute'), 10) === 3) {
                    orderDetail = _.assign(orderDetail, {
                        isVirtual: true,
                        mobile: _.get(orderDetail, 'deliveryInfo.mobile')
                    });
                }

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

                if (orderDetail.links) {
                    _.forEach(orderDetail.links, (val) => {
                        if (val === 'getExpress') {
                            orderDetail = _.assign(orderDetail, {
                                expressUrl: helpers.urlFormat('/home/logistic', {order_code: orderCode})
                            });
                            return;
                        }
                    });
                }

                _.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.packageInfo) {
                    orderDetail = _.assign(orderDetail, {
                        jitDetailUrl: helpers.urlFormat('/cart/index/new/jitDetail', {
                            orderCode: orderCode
                        }),
                        packageTitle: _.get(orderDetail, 'packageInfo.packageTitle')
                    });
                }

                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 {};
            }

        });
    }

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

    // 再次购买
    readdData(orderCode, uid) {
        return this.get({
            data: {
                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;
        });
    }

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

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

    /**
     * 申请退款
     */
    refundApply(params) {
        return this.get({
            data: {
                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
    */
    _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 this.get({
            data: finalParams
        });
    }

    /**
     * 获取物流详情页banner
     */
    _getLogisterBanner() {
        return this.get({
            url: 'operations/api/v5/resource/get',
            data: {content_code: CODE_LOGISTIC_BANNER},
            params: {code: 200},
            api: global.yoho.ServiceAPI
        });
    }

    /**
     * 查看物流
     *
     * @param int orderCode 订单编号
     * @param int uid 用户ID
     * @return array
     */
    logistics(params) {
        return Promise.all([
            this._getLogisterBanner(),
            this._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
     */
    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 this.get({
            data: apiParams
        });
    }
};