<template>
    <el-dialog v-model="data.dialogVisible" :title="ruleForm.id ? '编辑订单' : '创建订单'" :before-close="handleClose" width="600px">
        <el-form ref="formDataRef" :model="ruleForm" :rules="rules" label-width="120px">
            <el-form-item label="卖方" prop="sellerId">
                <el-select
                    v-model="ruleForm.sellerId"
                    clearable
                    filterable
                    remote
                    :remote-method="sellerRemoteMethod"
                    :loading="data.sellerLoading"
                    placeholder="请选择卖方"
                    style="width: 100%"
                >
                    <el-option
                        v-for="item in data.sellerOptions"
                        :key="item.id"
                        :label="item.username + ' / ' + item.mobile + ' (' + item.tenantName + ')'"
                        :value="item.id"
                    >
                    </el-option>
                    <el-pagination
                        style="padding: 0px 20px"
                        @current-change="sellerHandleCurrentChange"
                        :page-size="10"
                        :current-page="data.sellerPageNum"
                        layout="total, prev, pager, next"
                        :total="data.sellerTotal"
                    >
                    </el-pagination>
                </el-select>
            </el-form-item>
            
            <el-form-item label="买方" prop="buyerId">
                <el-select
                    v-model="ruleForm.buyerId"
                    clearable
                    filterable
                    remote
                    :remote-method="buyerRemoteMethod"
                    :loading="data.buyerLoading"
                    placeholder="请选择买方"
                    style="width: 100%"
                >
                    <el-option
                        v-for="item in data.buyerOptions"
                        :key="item.id"
                        :label="item.username + ' / ' + item.mobile + ' (' + item.tenantName + ')'"
                        :value="item.id"
                    >
                    </el-option>
                    <el-pagination
                        style="padding: 0px 20px"
                        @current-change="buyerHandleCurrentChange"
                        :page-size="10"
                        :current-page="data.buyerPageNum"
                        layout="total, prev, pager, next"
                        :total="data.buyerTotal"
                    >
                    </el-pagination>
                </el-select>
            </el-form-item>
            
            <el-form-item label="结算方式" prop="settlementType">
                <el-select v-model="ruleForm.settlementType" placeholder="请选择结算方式" style="width: 100%">
                    <el-option label="上车重量" :value="1"></el-option>
                    <el-option label="下车重量" :value="2"></el-option>
                    <el-option label="按肉价结算" :value="3"></el-option>
                </el-select>
            </el-form-item>
            
            <el-form-item label="约定价格(元/斤)" prop="firmPrice">
                <el-input-number
                    v-model="ruleForm.firmPrice"
                    :precision="4"
                    :min="0"
                    :max="999999.9999"
                    placeholder="请输入约定价格"
                    style="width: 100%"
                ></el-input-number>
            </el-form-item>
            
            <el-form-item label="预付款(元)" prop="advancePayment">
                <el-input-number
                    v-model="ruleForm.advancePayment"
                    :precision="2"
                    :min="0"
                    :max="9999999.99"
                    placeholder="请输入预付款"
                    style="width: 100%"
                ></el-input-number>
            </el-form-item>
        </el-form>
        
        <template #footer>
            <span class="dialog-footer">
                <el-button :loading="data.saveLoading" type="primary" @click="onClickSave">保存</el-button>
                <el-button @click="handleClose">取消</el-button>
            </span>
        </template>
    </el-dialog>
</template>

<script setup>
import { ref, reactive } from 'vue';
import { ElMessage } from 'element-plus';
import { orderAddNew, orderUpdate, updateDeliveryInfo, getOrdersByDeliveryId } from '@/api/shipping.js';
import { memberListByType } from '@/api/userManage.js';

const emits = defineEmits();
const formDataRef = ref(null);

const data = reactive({
    dialogVisible: false,
    saveLoading: false,
    sellerOptions: [],
    buyerOptions: [],
    sellerLoading: false,
    sellerPageNum: 1,
    sellerTotal: 0,
    sellerName: '',
    buyerLoading: false,
    buyerPageNum: 1,
    buyerTotal: 0,
    buyerName: '',
});

const ruleForm = reactive({
    id: null, // 订单ID（编辑时使用）
    buyerId: null, // 买方ID（单选）
    sellerId: null, // 卖方ID（单选）
    settlementType: 1, // 结算方式：1-上车重量，2-下车重量，3-按肉价结算
    firmPrice: null, // 约定价格（元/斤）
    advancePayment: null, // 预付款（元）
    deliveryId: null, // 运送清单ID（关联时使用）
});

// 验证买方和卖方不能是同一用户
const validateBuyerSeller = (rule, value, callback) => {
    if (value && value === ruleForm.sellerId) {
        callback(new Error('买方和卖方不能是同一用户'));
    } else {
        callback();
    }
};

const validateSellerBuyer = (rule, value, callback) => {
    if (value && value === ruleForm.buyerId) {
        callback(new Error('卖方和买方不能是同一用户'));
    } else {
        callback();
    }
};

const rules = reactive({
    buyerId: [
        { required: true, message: '请选择买方', trigger: 'change' },
        { validator: validateBuyerSeller, trigger: 'change' }
    ],
    sellerId: [
        { required: true, message: '请选择卖方', trigger: 'change' },
        { validator: validateSellerBuyer, trigger: 'change' }
    ],
    settlementType: [{ required: true, message: '请选择结算方式', trigger: 'change' }],
    firmPrice: [
        { required: true, message: '请输入约定价格', trigger: 'blur' },
        { type: 'number', min: 0, message: '约定价格不能小于0', trigger: 'blur' }
    ],
    advancePayment: [
        { required: true, message: '请输入预付款', trigger: 'blur' },
        { type: 'number', min: 0, message: '预付款不能小于0', trigger: 'blur' }
    ],
});

const handleClose = () => {
    if (formDataRef.value) {
        formDataRef.value.resetFields();
    }
    // 重置表单数据
    ruleForm.id = null;
    ruleForm.buyerId = null;
    ruleForm.sellerId = null;
    ruleForm.settlementType = 1;
    ruleForm.firmPrice = null;
    ruleForm.advancePayment = null;
    ruleForm.deliveryId = null;
    data.dialogVisible = false;
};

// ----------------
// 卖方远程搜索（同时查询 type=2 和 type=4）
const sellerRemoteMethod = (e) => {
    data.sellerName = e;
    data.sellerPageNum = 1;
    getSellerList();
};

// 卖方列表（合并 type=2 和 type=4 的用户）
const getSellerList = () => {
    data.sellerLoading = true;
    const searchName = data.sellerName || '';
    
    // 同时查询供应商（type=2）和采购商（type=4）
    Promise.all([
        memberListByType({
            pageNum: data.sellerPageNum,
            pageSize: 10,
            type: 2,
            username: searchName,
        }),
        memberListByType({
            pageNum: data.sellerPageNum,
            pageSize: 10,
            type: 4,
            username: searchName,
        })
    ])
        .then(([supplierRes, purchaserRes]) => {
            // 合并结果并去重（根据 id）
            const supplierList = supplierRes.data.rows || [];
            const purchaserList = purchaserRes.data.rows || [];
            const mergedList = [...supplierList, ...purchaserList];
            
            // 去重：使用 Map 根据 id 去重
            const uniqueMap = new Map();
            mergedList.forEach(item => {
                if (!uniqueMap.has(item.id)) {
                    uniqueMap.set(item.id, item);
                }
            });
            data.sellerOptions = Array.from(uniqueMap.values());
            
            // 总数取两个查询的总和（实际可能包含重复，但用于分页显示）
            data.sellerTotal = (supplierRes.data.total || 0) + (purchaserRes.data.total || 0);
            data.sellerLoading = false;
        })
        .catch(() => {
            data.sellerLoading = false;
        });
};

// 卖方分页
const sellerHandleCurrentChange = (val) => {
    data.sellerPageNum = val;
    getSellerList();
};

// ----------------
// 买方远程搜索（同时查询 type=2 和 type=4）
const buyerRemoteMethod = (e) => {
    data.buyerName = e;
    data.buyerPageNum = 1;
    getBuyerList();
};

// 买方列表（合并 type=2 和 type=4 的用户）
const getBuyerList = () => {
    data.buyerLoading = true;
    const searchName = data.buyerName || '';
    
    // 同时查询供应商（type=2）和采购商（type=4）
    Promise.all([
        memberListByType({
            pageNum: data.buyerPageNum,
            pageSize: 10,
            type: 2,
            username: searchName,
        }),
        memberListByType({
            pageNum: data.buyerPageNum,
            pageSize: 10,
            type: 4,
            username: searchName,
        })
    ])
        .then(([supplierRes, purchaserRes]) => {
            // 合并结果并去重（根据 id）
            const supplierList = supplierRes.data.rows || [];
            const purchaserList = purchaserRes.data.rows || [];
            const mergedList = [...supplierList, ...purchaserList];
            
            // 去重：使用 Map 根据 id 去重
            const uniqueMap = new Map();
            mergedList.forEach(item => {
                if (!uniqueMap.has(item.id)) {
                    uniqueMap.set(item.id, item);
                }
            });
            data.buyerOptions = Array.from(uniqueMap.values());
            
            // 总数取两个查询的总和（实际可能包含重复，但用于分页显示）
            data.buyerTotal = (supplierRes.data.total || 0) + (purchaserRes.data.total || 0);
            data.buyerLoading = false;
        })
        .catch(() => {
            data.buyerLoading = false;
        });
};

// 买方分页
const buyerHandleCurrentChange = (val) => {
    data.buyerPageNum = val;
    getBuyerList();
};

// 保存
const onClickSave = () => {
    if (formDataRef.value) {
        formDataRef.value.validate((valid) => {
            if (valid) {
                const params = {
                    id: ruleForm.id,
                    buyerId: ruleForm.buyerId ? String(ruleForm.buyerId) : '', // 转为字符串格式（后端可能期望字符串）
                    sellerId: ruleForm.sellerId ? String(ruleForm.sellerId) : '', // 转为字符串格式
                    settlementType: ruleForm.settlementType,
                    firmPrice: ruleForm.firmPrice, // 约定价格（元/斤）
                    advancePayment: ruleForm.advancePayment, // 预付款（元）
                };
                
                // 如果是新增订单且有deliveryId，传递deliveryId参数
                if (!ruleForm.id && ruleForm.deliveryId) {
                    params.deliveryId = ruleForm.deliveryId;
                }
                
                data.saveLoading = true;
                
                // 根据是否有ID判断是新增还是编辑
                const savePromise = ruleForm.id ? orderUpdate(params) : orderAddNew(params);
                
                savePromise.then(async (res) => {
                    data.saveLoading = false;
                    if (res.code === 200) {
                        // 如果是新增订单且有deliveryId，需要更新delivery表的order_id字段
                        if (!ruleForm.id && ruleForm.deliveryId) {
                            // 尝试从响应中获取订单ID
                            let orderId = null;
                            if (res.data) {
                                // 如果返回的是订单对象
                                if (res.data.id) {
                                    orderId = res.data.id;
                                } 
                                // 如果返回的是订单ID（数字或字符串）
                                else if (typeof res.data === 'number' || typeof res.data === 'string') {
                                    orderId = res.data;
                                }
                            }
                            
                            // 如果获取到了订单ID，更新delivery表的order_id字段
                            if (orderId) {
                                try {
                                    // 更新delivery表的order_id字段
                                    const updateRes = await updateDeliveryInfo({
                                        deliveryId: ruleForm.deliveryId, // 使用deliveryId而不是id
                                        orderId: String(orderId) // 转为字符串格式
                                    });
                                    if (updateRes.code === 200) {
                                        ElMessage({
                                            message: '订单创建成功，已关联运送清单',
                                            type: 'success',
                                        });
                                    } else {
                                        ElMessage.warning('订单创建成功，但关联运送清单失败：' + (updateRes.msg || '未知错误'));
                                    }
                                } catch (error) {
                                    console.error('更新运送清单关联失败:', error);
                                    ElMessage.warning('订单创建成功，但关联运送清单失败，请手动关联');
                                }
                            } else {
                                // 如果无法获取订单ID，提示用户
                                ElMessage.warning('订单创建成功，但无法自动关联运送清单，请手动关联');
                            }
                        } else {
                            ElMessage({
                                message: res.msg,
                                type: 'success',
                            });
                        }
                        emits('success');
                        handleClose();
                    } else {
                        ElMessage.error(res.msg);
                    }
                })
                .catch((err) => {
                    data.saveLoading = false;
                    ElMessage.error('保存失败：' + (err.message || '未知错误'));
                });
            } else {

            }
        });
    }
};

// 根据名称查找用户ID（卖方）
const findSellerIdByName = async (sellerName) => {
    if (!sellerName || sellerName.trim() === '') {
        return null;
    }
    
    try {
        // 设置搜索名称并查询
        data.sellerName = sellerName.trim();
        data.sellerPageNum = 1;
        
        // 同时查询供应商（type=2）和采购商（type=4）
        const [supplierRes, purchaserRes] = await Promise.all([
            memberListByType({
                pageNum: 1,
                pageSize: 100, // 增加查询数量以提高匹配概率
                type: 2,
                username: sellerName.trim(),
            }),
            memberListByType({
                pageNum: 1,
                pageSize: 100,
                type: 4,
                username: sellerName.trim(),
            })
        ]);
        
        // 合并结果并去重
        const supplierList = supplierRes.data.rows || [];
        const purchaserList = purchaserRes.data.rows || [];
        const mergedList = [...supplierList, ...purchaserList];
        
        // 去重：使用 Map 根据 id 去重
        const uniqueMap = new Map();
        mergedList.forEach(item => {
            if (!uniqueMap.has(item.id)) {
                uniqueMap.set(item.id, item);
            }
        });
        const allSellers = Array.from(uniqueMap.values());
        
        // 精确匹配用户名
        const matchedSeller = allSellers.find(item => 
            item.username === sellerName.trim() || 
            item.username?.includes(sellerName.trim()) ||
            item.mobile === sellerName.trim()
        );
        
        if (matchedSeller) {
            // 将匹配的用户添加到选项列表中
            if (!data.sellerOptions.find(item => item.id === matchedSeller.id)) {
                data.sellerOptions.unshift(matchedSeller);
            }
            return matchedSeller.id;
        }
        
        // 如果没有精确匹配，返回第一个结果（如果存在）
        if (allSellers.length > 0) {
            if (!data.sellerOptions.find(item => item.id === allSellers[0].id)) {
                data.sellerOptions.unshift(allSellers[0]);
            }
            return allSellers[0].id;
        }
        
        return null;
    } catch (error) {
        console.error('查找卖方失败:', error);
        return null;
    }
};

// 根据名称查找用户ID（买方）
const findBuyerIdByName = async (buyerName) => {
    if (!buyerName || buyerName.trim() === '') {
        return null;
    }
    
    try {
        // 设置搜索名称并查询
        data.buyerName = buyerName.trim();
        data.buyerPageNum = 1;
        
        // 同时查询供应商（type=2）和采购商（type=4）
        const [supplierRes, purchaserRes] = await Promise.all([
            memberListByType({
                pageNum: 1,
                pageSize: 100, // 增加查询数量以提高匹配概率
                type: 2,
                username: buyerName.trim(),
            }),
            memberListByType({
                pageNum: 1,
                pageSize: 100,
                type: 4,
                username: buyerName.trim(),
            })
        ]);
        
        // 合并结果并去重
        const supplierList = supplierRes.data.rows || [];
        const purchaserList = purchaserRes.data.rows || [];
        const mergedList = [...supplierList, ...purchaserList];
        
        // 去重：使用 Map 根据 id 去重
        const uniqueMap = new Map();
        mergedList.forEach(item => {
            if (!uniqueMap.has(item.id)) {
                uniqueMap.set(item.id, item);
            }
        });
        const allBuyers = Array.from(uniqueMap.values());
        
        // 精确匹配用户名
        const matchedBuyer = allBuyers.find(item => 
            item.username === buyerName.trim() || 
            item.username?.includes(buyerName.trim()) ||
            item.mobile === buyerName.trim()
        );
        
        if (matchedBuyer) {
            // 将匹配的用户添加到选项列表中
            if (!data.buyerOptions.find(item => item.id === matchedBuyer.id)) {
                data.buyerOptions.unshift(matchedBuyer);
            }
            return matchedBuyer.id;
        }
        
        // 如果没有精确匹配，返回第一个结果（如果存在）
        if (allBuyers.length > 0) {
            if (!data.buyerOptions.find(item => item.id === allBuyers[0].id)) {
                data.buyerOptions.unshift(allBuyers[0]);
            }
            return allBuyers[0].id;
        }
        
        return null;
    } catch (error) {
        console.error('查找买方失败:', error);
        return null;
    }
};

// 根据ID查找用户信息并添加到选项列表（卖方）
const loadSellerById = async (sellerId) => {
    if (!sellerId) {
        return null;
    }
    
    try {
        const id = typeof sellerId === 'string' ? parseInt(sellerId.split(',')[0]) : sellerId;
        
        // 先检查是否已经在选项列表中
        const existingSeller = data.sellerOptions.find(item => item.id === id);
        if (existingSeller) {
            return id;
        }
        
        // 如果没有，尝试通过搜索查找（使用空字符串搜索所有用户）
        data.sellerName = '';
        data.sellerPageNum = 1;
        
        const [supplierRes, purchaserRes] = await Promise.all([
            memberListByType({
                pageNum: 1,
                pageSize: 100,
                type: 2,
                username: '',
            }),
            memberListByType({
                pageNum: 1,
                pageSize: 100,
                type: 4,
                username: '',
            })
        ]);
        
        const supplierList = supplierRes.data.rows || [];
        const purchaserList = purchaserRes.data.rows || [];
        const mergedList = [...supplierList, ...purchaserList];
        
        const foundSeller = mergedList.find(item => item.id === id);
        if (foundSeller) {
            if (!data.sellerOptions.find(item => item.id === foundSeller.id)) {
                data.sellerOptions.unshift(foundSeller);
            }
            return id;
        }
        
        return id; // 即使找不到用户信息，也返回ID
    } catch (error) {
        console.error('根据ID加载卖方失败:', error);
        return sellerId;
    }
};

// 根据ID查找用户信息并添加到选项列表（买方）
const loadBuyerById = async (buyerId) => {
    if (!buyerId) {
        return null;
    }
    
    try {
        const id = typeof buyerId === 'string' ? parseInt(buyerId.split(',')[0]) : buyerId;
        
        // 先检查是否已经在选项列表中
        const existingBuyer = data.buyerOptions.find(item => item.id === id);
        if (existingBuyer) {
            return id;
        }
        
        // 如果没有，尝试通过搜索查找（使用空字符串搜索所有用户）
        data.buyerName = '';
        data.buyerPageNum = 1;
        
        const [supplierRes, purchaserRes] = await Promise.all([
            memberListByType({
                pageNum: 1,
                pageSize: 100,
                type: 2,
                username: '',
            }),
            memberListByType({
                pageNum: 1,
                pageSize: 100,
                type: 4,
                username: '',
            })
        ]);
        
        const supplierList = supplierRes.data.rows || [];
        const purchaserList = purchaserRes.data.rows || [];
        const mergedList = [...supplierList, ...purchaserList];
        
        const foundBuyer = mergedList.find(item => item.id === id);
        if (foundBuyer) {
            if (!data.buyerOptions.find(item => item.id === foundBuyer.id)) {
                data.buyerOptions.unshift(foundBuyer);
            }
            return id;
        }
        
        return id; // 即使找不到用户信息，也返回ID
    } catch (error) {
        console.error('根据ID加载买方失败:', error);
        return buyerId;
    }
};

const onShowDialog = async (orderData, deliveryId) => {
    if (formDataRef.value) {
        formDataRef.value.resetFields();
    }
    
    // 重置表单数据
    ruleForm.id = orderData?.id || null;
    
    // 处理buyerId：优先使用buyerName查找，如果没有名称则使用buyerId
    if (orderData?.buyerName) {
        // 优先根据名称查找
        const foundBuyerId = await findBuyerIdByName(orderData.buyerName);
        ruleForm.buyerId = foundBuyerId;
        
        // 如果名称查找失败，但有buyerId，则使用ID并加载用户信息
        if (!foundBuyerId && orderData?.buyerId) {
            const buyerId = typeof orderData.buyerId === 'number' 
                ? orderData.buyerId 
                : (Array.isArray(orderData.buyerId) && orderData.buyerId.length > 0 
                    ? parseInt(orderData.buyerId[0]) 
                    : (typeof orderData.buyerId === 'string' && orderData.buyerId.trim() !== ''
                        ? parseInt(orderData.buyerId.split(',')[0])
                        : null));
            if (buyerId) {
                ruleForm.buyerId = await loadBuyerById(buyerId);
            }
        }
    } else if (orderData?.buyerId) {
        // 如果没有名称但有ID，使用ID并加载用户信息
        const buyerId = typeof orderData.buyerId === 'number' 
            ? orderData.buyerId 
            : (Array.isArray(orderData.buyerId) && orderData.buyerId.length > 0 
                ? parseInt(orderData.buyerId[0]) 
                : (typeof orderData.buyerId === 'string' && orderData.buyerId.trim() !== ''
                    ? parseInt(orderData.buyerId.split(',')[0])
                    : null));
        if (buyerId) {
            ruleForm.buyerId = await loadBuyerById(buyerId);
        } else {
            ruleForm.buyerId = null;
        }
    } else {
        ruleForm.buyerId = null;
    }
    
    // 处理sellerId：优先使用sellerName查找，如果没有名称则使用sellerId
    if (orderData?.sellerName) {
        // 优先根据名称查找
        const foundSellerId = await findSellerIdByName(orderData.sellerName);
        ruleForm.sellerId = foundSellerId;
        
        // 如果名称查找失败，但有sellerId，则使用ID并加载用户信息
        if (!foundSellerId && orderData?.sellerId) {
            const sellerId = typeof orderData.sellerId === 'number' 
                ? orderData.sellerId 
                : (Array.isArray(orderData.sellerId) && orderData.sellerId.length > 0 
                    ? parseInt(orderData.sellerId[0]) 
                    : (typeof orderData.sellerId === 'string' && orderData.sellerId.trim() !== ''
                        ? parseInt(orderData.sellerId.split(',')[0])
                        : null));
            if (sellerId) {
                ruleForm.sellerId = await loadSellerById(sellerId);
            }
        }
    } else if (orderData?.sellerId) {
        // 如果没有名称但有ID，使用ID并加载用户信息
        const sellerId = typeof orderData.sellerId === 'number' 
            ? orderData.sellerId 
            : (Array.isArray(orderData.sellerId) && orderData.sellerId.length > 0 
                ? parseInt(orderData.sellerId[0]) 
                : (typeof orderData.sellerId === 'string' && orderData.sellerId.trim() !== ''
                    ? parseInt(orderData.sellerId.split(',')[0])
                    : null));
        if (sellerId) {
            ruleForm.sellerId = await loadSellerById(sellerId);
        } else {
            ruleForm.sellerId = null;
        }
    } else {
        ruleForm.sellerId = null;
    }
    
    ruleForm.settlementType = orderData?.settlementType || 1;
    ruleForm.firmPrice = orderData?.firmPrice != null ? orderData.firmPrice : null;
    
    // 设置deliveryId（如果提供）
    ruleForm.deliveryId = deliveryId || orderData?.deliveryId || null;
    
    // 处理预付款：编辑时使用订单值，新建时保持为空
    if (orderData?.advancePayment != null) {
        ruleForm.advancePayment = orderData.advancePayment;
    } else {
        ruleForm.advancePayment = null;
    }
    
    data.dialogVisible = true;
    // 初始化时加载列表（如果选项列表为空，则加载默认列表）
    if (data.sellerOptions.length === 0) {
        getSellerList();
    }
    if (data.buyerOptions.length === 0) {
        getBuyerList();
    }
};

defineExpose({
    onShowDialog,
});
</script>

<style lang="less" scoped>
::v-deep .el-select-dropdown__list {
    padding-bottom: 40px;
}
</style>
