import Chat from "@/customer-service/xim";
import { metaRow, UniplatSdkExtender, UniplatSdk } from "uniplat-sdk";
import {
    OperationType,
    OrderStatus,
    OrderTableListItem,
    orderPredict,
    SrcPlatform,
    OrderPayItem,
    UploadImageItem,
    orderPayItemPredict,
    OrderComment,
    PayStatus,
} from "../model";
import { GeneralOrderDirection } from "../model/order-product";

class OrderService {
    public readonly generalOrder = "general_order_info";
    public readonly generalOrderPaymentModel = "general_order_payment_info";
    public readonly generalOrderDefaultDetailName = "userOrderDetail";
    private readonly commentModel = "uniplat_model_remark@general_order";
    private readonly fileModel = "general_order_payment_file_info";

    private readonly handler = new UniplatSdkExtender();
    private innerSdk: UniplatSdk | null = null;

    public injectSdk(sdk: UniplatSdk) {
        this.innerSdk = sdk;
        return this;
    }

    private getSdk() {
        return this.innerSdk || Chat.getSdk();
    }

    public openOrder(params: {
        productCode: string;
        srcPlatform: SrcPlatform;
        createdType: OperationType;
        /**
         * 是否强制开启新订单，默认如果有已存在处理中的订单时会直接返回
         */
        forceNewOrder?: boolean;
    }) {
        return this.getSdk()
            .model(this.generalOrder)
            .action(params.forceNewOrder ? "addOrder" : "getOrAddOrder")
            .addInputs_parameter({
                ProductCode: params.productCode,
                SrcPlatform: params.srcPlatform,
                CreatedType: params.createdType,
            })
            .execute();
    }

    public updateOrderStatus(
        id: number | string,
        v: number,
        status: OrderStatus
    ) {
        return this.getSdk()
            .model(this.generalOrder)
            .action("editStatus")
            .addInputs_parameter({
                Status: status,
                userType: OperationType.User,
            })
            .updateInitialParams({ selected_list: [{ v, id: +id }] })
            .execute();
    }

    /** 专项工单 */
    public getOrders(
        params: {
            productCode?: GeneralOrderDirection;
            index: number;
            size?: number;
        },
        isHrs = false
    ) {
        const list = this.getSdk()
            .model(this.generalOrder)
            .list(isHrs ? "hroOrgOrderList" : "userOrderList");
        if (params.productCode) {
            list.addPrefilter({ "ProductId#product.Code": params.productCode });
        }
        return list
            .query({ item_size: params.size || 100, pageIndex: params.index })
            .then((r) => {
                return {
                    total: r.pageData.record_count,
                    list: this.handler.buildRows<OrderTableListItem>(
                        r.pageData.rows,
                        orderPredict
                    ),
                };
            });
    }

    public getProcessOrders(params: {
        productCode?: GeneralOrderDirection;
        index: number;
        size?: number;
    }) {
        const list = this.getSdk()
            .model(this.generalOrder)
            .list("hroOrgDoingOrderList");
        if (params.productCode) {
            list.addPrefilter({ "ProductId#product.Code": params.productCode });
        }
        return list
            .query({ item_size: params.size || 100, pageIndex: params.index })
            .then((r) => {
                return {
                    total: r.pageData.record_count,
                    list: this.handler.buildRows<OrderTableListItem>(
                        r.pageData.rows,
                        orderPredict
                    ),
                };
            });
    }

    /**
     * 获取订单支付记录
     * @param id 订单id
     * @param withActions 是否获取行数据中action条目
     */
    public getPayments(id: number, withActions = false) {
        return this.getSdk()
            .model(orderService.generalOrderPaymentModel)
            .list(withActions ? "" : "userOrderPaymentList")
            .addPrefilter({ OrderId: id })
            .query({ pageIndex: 1, item_size: 100 })
            .then((r) => {
                if (r && r.pageData && r.pageData.rows) {
                    let items = this.handler.buildRows<OrderPayItem>(
                        r.pageData.rows,
                        orderPayItemPredict
                    );
                    items = items.filter(
                        (i) =>
                            i.status !== PayStatus.Deleted &&
                            i.status !== PayStatus.Cancel
                    );
                    if (withActions) {
                        for (let i = 0; i < r.pageData.rows.length; i++) {
                            r.pageData &&
                                r.pageData.rows &&
                                r.pageData.rows[i] &&
                                (items[i].actions = r.pageData.rows[i].actions);
                        }
                    }

                    return items;
                }
                return [];
            });
    }

    public getPayment(id: string | number) {
        return this.getSdk()
            .model(orderService.generalOrderPaymentModel)
            .detail(id as string, "userOrderPaymentDetail")
            .query()
            .then((r) =>
                this.handler.buildRow<OrderPayItem>(r.row, orderPayItemPredict)
            );
    }

    public addImage4Payment(payment: number | string, v: number, path: string) {
        return this.getSdk()
            .model(orderService.generalOrderPaymentModel)
            .action("addImages")
            .updateInitialParams({
                selected_list: [{ v, id: payment as number }],
            })
            .addInputs_parameter({ images: path })
            .execute();
    }

    public getImages4Payment(payment: number) {
        return this.getSdk()
            .model(this.fileModel)
            .list()
            .addPrefilter({ PaymentId: payment })
            .query({ item_size: 10, pageIndex: 1 })
            .then((r) =>
                this.handler.buildRows<UploadImageItem>(r.pageData.rows, {
                    time: "CreatedDate",
                    fileSize: "FileSize",
                    fileName: "FileName",
                    url: "Url",
                    id: "ID",
                    v: "uniplat_version",
                })
            );
    }

    public deleteImage(payment: number, image: number, v: number) {
        return this.getSdk()
            .model(this.fileModel)
            .action("delete")
            .updateInitialParams({
                selected_list: [{ v, id: image }],
                prefilters: [{ property: "PaymentId", value: payment }],
            })
            .execute();
    }

    public buildOrder(o: metaRow) {
        return this.handler.buildRow<OrderTableListItem>(o, orderPredict);
    }

    /** 设置备注 */
    public setRemark(
        id: string,
        v: number,
        data: { Title: string; Remark: string }
    ) {
        return this.getSdk()
            .model(this.generalOrder)
            .action("editTitle")
            .updateInitialParams({ selected_list: [{ v, id: +id }] })
            .addInputs_parameter(data)
            .execute();
    }

    public getOrderDetail(id: number | string) {
        return this.getSdk()
            .model(this.generalOrder)
            .detail(id as string)
            .query();
    }

    public sendPayAccountInfo(params: { send: string; type?: number }) {
        return this.getSdk()
            .domainService("hro_spview", "OrderSetting", "sendPayAccountInfo")
            .request("get", { params });
    }

    public sendPayAccountInfoForAgent(params: {
        send: string;
        userOrderPaymentId: number;
    }) {
        return this.getSdk()
            .domainService(
                "hro_spview",
                "OrderSetting",
                "sendPayAccountInfoForAgent"
            )
            .request("get", { params });
    }

    public getComments(order: number | string) {
        return this.getSdk()
            .model(orderService.commentModel)
            .list("system_remark")
            .addPrefilter({ associate_id: order })
            .query({ pageIndex: 1, item_size: 100 })
            .then((r) => {
                if (r && r.pageData && r.pageData.rows) {
                    const items = this.handler.buildRows<OrderComment>(
                        r.pageData.rows,
                        {
                            id: "",
                            time: "create_time",
                            attachment: "attachments_label",
                            user: "dealer_name",
                            content: "",
                        }
                    );

                    return items;
                }
                return [];
            });
    }
}

export const orderService = new OrderService();