fastadmin_lottery/public/assets/js/backend/lottery/activity.js

define(['jquery', 'bootstrap', 'backend', 'table', 'form', 'template'], function ($, undefined, Backend, Table, Form, Template) {

    var Controller = {
        index: function () {
            // 初始化表格参数
            Table.api.init({
                extend: {
                    index_url: 'lottery/activity/index' + location.search,
                    add_url: 'lottery/activity/add',
                    edit_url: 'lottery/activity/edit',
                    del_url: 'lottery/activity/del',
                    multi_url: 'lottery/activity/multi',
                    import_url: 'lottery/activity/import',
                    table: 'shop_lottery_activity',
                }
            });

            var table = $("#table");

            // 初始化表格
            table.bootstrapTable({
                url: $.fn.bootstrapTable.defaults.extend.index_url,
                pk: 'id',
                sortName: 'id',
                fixedColumns: true,
                fixedRightNumber: 1,
                columns: [
                    [
                        {checkbox: true},
                        {field: 'id', title: __('Id'), operate: false},
                        {field: 'name', title: __('活动名称'), operate: 'LIKE'},
                        {field: 'type', title: __('活动类型'), searchList:  Controller.api.parseConfigJson("typeList"), formatter: Table.api.formatter.normal},
                        {field: 'status', title: __('状态'), searchList:  Controller.api.parseConfigJson("statusList"), formatter: Table.api.formatter.status},
                        {field: 'lottery_type', title: __('开奖方式'), searchList:  Controller.api.parseConfigJson("lotteryTypeList"), formatter: Table.api.formatter.normal},
                        {field: 'start_time', title: __('开始时间'), operate:'RANGE', addclass:'datetimerange', autocomplete:false, formatter: Table.api.formatter.datetime},
                        {field: 'end_time', title: __('结束时间'), operate:'RANGE', addclass:'datetimerange', autocomplete:false, formatter: Table.api.formatter.datetime},
                        {field: 'total_people_count', title: __('参与人数'), operate: false},
                        {field: 'total_draw_count', title: __('抽奖次数'), operate: false},
                        {field: 'total_win_count', title: __('中奖次数'), operate: false},
                        {field: 'createtime', title: __('Create time'), operate:'RANGE', addclass:'datetimerange', autocomplete:false, formatter: Table.api.formatter.datetime},
                        {field: 'operate', title: __('Operate'), table: table, events: Table.api.events.operate, 
                            buttons: [
                                // {
                                //     name: 'prize',
                                //     title: __('奖品管理'),
                                //     classname: 'btn btn-xs btn-success btn-magic btn-ajax',
                                //     icon: 'fa fa-gift',
                                //     url: 'lottery/activity/prize',
                                //     callback: function (data) {
                                //         Layer.alert("接收到回传数据：" + JSON.stringify(data), {title: "回传数据"});
                                //     },
                                //     visible: function (row) {
                                //         //返回true时按钮显示,返回false隐藏
                                //         return true;
                                //     }
                                // },
                                // {
                                //     name: 'condition',
                                //     title: __('参与条件'),
                                //     classname: 'btn btn-xs btn-info btn-magic btn-ajax',
                                //     icon: 'fa fa-tasks',
                                //     url: 'lottery/activity/condition'
                                // },
                                // {
                                //     name: 'records',
                                //     title: __('抽奖记录'),
                                //     classname: 'btn btn-xs btn-warning btn-magic btn-ajax',
                                //     icon: 'fa fa-list',
                                //     url: 'lottery/activity/records'
                                // },
                                // {
                                //     name: 'statistics',
                                //     title: __('统计数据'),
                                //     classname: 'btn btn-xs btn-primary btn-magic btn-ajax',
                                //     icon: 'fa fa-bar-chart',
                                //     url: 'lottery/activity/statistics'
                                // }
                            ],
                            formatter: Table.api.formatter.operate
                        }
                    ]
                ]
            });

            // 为表格绑定事件
            Table.api.bindevent(table);
        },
        add: function () {
            Controller.api.bindevent();
            Controller.api.initAddPage();
        },
        edit: function () {
            Controller.api.bindevent();
            Controller.api.initEditPage();
        },
        api: {
            // 解析Config中的JSON字符串的辅助函数
            parseConfigJson: function(configKey, defaultValue) {
                var configValue = Config[configKey] || defaultValue || {};
                
                // 如果是字符串，尝试解析JSON
                if (typeof configValue === 'string') {
                    try {
                        return JSON.parse(configValue);
                    } catch (e) {
                        return defaultValue || {};
                    }
                }
                
                return configValue;
            },
            
            bindevent: function () {
                Form.api.bindevent($("form[role=form]"));
            },
            
            // 初始化添加页面
            initAddPage: function() {
                // 初始化基础UI组件
                Controller.api.initBasicUI();
                
                // 初始化奖品数据管理器
                Controller.api.prizesDataManager.init();
                
                // 初始化规则数据管理器
                Controller.api.rulesDataManager.init();
                
                // 同步DOM中现有的奖品数据到数据管理器
                Controller.api.syncExistingPrizesToDataManager();
                
                // 初始化奖品管理
                Controller.api.initPrizeManagement();
                
                // 初始化任务规则管理
                Controller.api.initTaskRuleManagement();
                
                // 确保系统默认项有正确的概率值
                Controller.api.initDefaultPrizeRate();
                
                // 确保DOM渲染完成后再计算奖品数量
                setTimeout(function() {
                    console.log('页面初始化 - 开始更新奖品计数');
                    Controller.api.updatePrizeCount();
                }, 50);
                
                // 再次延迟调用，确保所有DOM都已渲染
                setTimeout(function() {
                    console.log('页面初始化 - 二次更新奖品计数');
                    Controller.api.updatePrizeCount();
                }, 500);
                
                // 初始化表单验证
                Controller.api.initFormValidation();
            },
            
            // 初始化基础UI组件
            initBasicUI: function() {
                // 活动名称字数统计
                $('#c-name').on('input', function(){
                    var len = $(this).val().length;
                    $('#activity-name-count').text(len + '/24');
                });
            },
            
            // 初始化任务规则管理
            initTaskRuleManagement: function() {
                // 任务类型切换（复选框）
                $(document).on('change', 'input[name="row[task_type][]"]', function() {
                    Controller.api.handleTaskTypeChange();
                });
                
                // 商品规则切换
                $(document).on('change', 'input[name^="condition"][name$="[goods_rule]"]', function() {
                    Controller.api.updateGoodsRuleDisplay($(this));
                    // 更新规则数据管理器
                    Controller.api.updateRulesDataFromDOM();
                });
                
                // 条件值输入框变化事件
                $(document).on('input change', 'input[name^="condition"][name$="[condition_value]"]', function() {
                    // 更新规则数据管理器
                    Controller.api.updateRulesDataFromDOM();
                });
                
                // 初始化任务类型状态
                Controller.api.initTaskTypeState();
            },
            
            // 处理任务类型变化
            handleTaskTypeChange: function() {
                var checkedTypes = $('input[name="row[task_type][]"]:checked');
                
                // 更新复选框样式
                $('input[name="row[task_type][]"]').each(function() {
                    var label = $(this).closest('label');
                    if ($(this).is(':checked')) {
                        label.addClass('checked');
                    } else {
                        label.removeClass('checked');
                    }
                });
                
                // 隐藏所有任务设置项
                $('.task-setting-item').hide();
                
                // 显示选中的任务设置项
                checkedTypes.each(function() {
                    var type = parseInt($(this).val());
                    $('#task-setting-' + type).show();
                });
                
                // 更新验证规则
                Controller.api.updateTaskValidation();
                
                // 更新规则数据管理器
                Controller.api.updateRulesDataFromDOM();
            },
            
            // 初始化任务类型状态
            initTaskTypeState: function() {
                var checkedTasks = $('input[name="row[task_type][]"]:checked');
                
                // 初始化复选框样式
                $('input[name="row[task_type][]"]').each(function() {
                    var label = $(this).closest('label');
                    if ($(this).is(':checked')) {
                        label.addClass('checked');
                    } else {
                        label.removeClass('checked');
                    }
                });
                
                // 初始化任务设置区域显示
                $('.task-setting-item').hide();
                
                checkedTasks.each(function() {
                    var type = parseInt($(this).val());
                    $('#task-setting-' + type).show();
                });
            },
            
            // 更新商品规则显示
            updateGoodsRuleDisplay: function($radio) {
                var container = $radio.closest('.task-setting-item');
                var rule = $radio.val();
                var helpText = container.find('.goods-description-box');
                
                if (rule == '1') {
                    helpText.html('<span class="text-muted">指定商品下单后将自动触发抽奖活动且发放一次抽奖机会，若用户产生维权退款，已发放的奖励自动回收。</span>');
                } else {
                    helpText.html('<span class="text-muted">除指定商品外的其他商品下单后将自动触发抽奖活动且发放一次抽奖机会。</span>');
                }
            },
            
            // 更新任务验证规则
            updateTaskValidation: function() {
                var checkedTypes = $('input[name="row[task_type][]"]:checked');
                
                // 移除旧的验证规则
                $('[name^="condition"]').removeAttr('data-rule');
                
                // 为选中的任务类型添加验证规则
                checkedTypes.each(function() {
                    var type = parseInt($(this).val());
                    
                    switch(type) {
                        case 1: // 购买指定商品
                            // 商品选择验证会在选择商品时处理
                            break;
                        case 2: // 单笔订单消费满额
                        case 3: // 单次充值满额  
                        case 4: // 活动期间累计消费满额
                            $('[name="condition[' + type + '][condition_value]"]').attr('data-rule', 'required;number(0.01~999999.99)');
                            break;
                    }
                });
            },            
            // 初始化表单验证
            initFormValidation: function() {
                // 添加自定义验证规则 - 验证奖品JSON数据
                if (typeof Nice !== 'undefined' && Nice.Validator) {
                    Nice.Validator.addRule('prizesJson', function(val, el) {
                        try {
                            var prizes = JSON.parse(val || '[]');
                            
                            // 验证是否有奖品
                            if (!prizes || prizes.length === 0) {
                                return false;
                            }
                            
                            // 验证每个奖品的基本字段
                            for (var i = 0; i < prizes.length; i++) {
                                var prize = prizes[i];
                                if (!prize.name || !prize.type || !prize.image) {
                                    return false;
                                }
                                // 验证概率值
                                if (typeof prize.rate !== 'number' || prize.rate < 0 || prize.rate > 100) {
                                    return false;
                                }
                            }
                            
                            return true;
                        } catch (e) {
                            return false;
                        }
                    }, '奖品数据不完整或格式错误');
                    
                    // 添加自定义验证规则 - 验证规则JSON数据
                    Nice.Validator.addRule('rulesJson', function(val, el) {
                        try {
                            var rules = JSON.parse(val || '{}');
                            
                            // 验证是否有规则
                            if (!rules || Object.keys(rules).length === 0) {
                                return false;
                            }
                            
                            // 验证每个规则的基本字段
                            for (var type in rules) {
                                var rule = rules[type];
                                if (!rule.type) {
                                    return false;
                                }
                                
                                // 根据类型验证特定字段
                                switch(parseInt(type)) {
                                    case 1: // 购买指定商品
                                        if (!rule.goods_ids || !Array.isArray(JSON.parse(rule.goods_ids || '[]'))) {
                                            return false;
                                        }
                                        break;
                                    case 2: // 单笔订单消费满额
                                    case 3: // 单次充值满额
                                    case 4: // 活动期间累计消费满额
                                        if (!rule.condition_value || parseFloat(rule.condition_value) <= 0) {
                                            return false;
                                        }
                                        break;
                                }
                            }
                            
                            return true;
                        } catch (e) {
                            return false;
                        }
                    }, '规则设置不完整或格式错误');
                }
                
                // 监听表单提交事件
                $('form[role="form"]').on('submit', function(e) {
                    console.log('表单提交开始');
                    
                    // 验证任务规则设置
                    if (!Controller.api.validateTaskRules()) {
                        e.preventDefault();
                        return false;
                    }
                    
                    // 收集规则数据并保存到隐藏域
                    Controller.api.collectAndSaveRulesData();
                    
                    return true;
                });
            },            
            // 初始化编辑页面
            initEditPage: function() {
                // 初始化基础UI组件
                Controller.api.initBasicUI();
                
                // 初始化奖品数据管理器
                Controller.api.prizesDataManager.init();
                
                // 初始化规则数据管理器
                Controller.api.rulesDataManager.init();
                
                // 初始化奖品管理
                Controller.api.initPrizeManagement();
                
                // 初始化任务规则管理
                Controller.api.initTaskRuleManagement();
                
                // 初始化已有的奖品数据
                Controller.api.initExistingPrizes();
                
                // 初始化已有的规则数据
                Controller.api.initExistingRules();
                
                // 初始化已有的条件数据
                Controller.api.initExistingConditions();
                
                // 确保所有概率输入框有正确的值
                setTimeout(function() {
                    Controller.api.initDefaultPrizeRate();
                }, 100);
                
                // 初始化表单验证
                Controller.api.initFormValidation();
                
                console.log('编辑页面初始化完成');
            },
            
            // 同步DOM中现有的奖品数据到数据管理器
            syncExistingPrizesToDataManager: function() {
                console.log('开始同步DOM中现有的奖品数据到数据管理器');
                
                var existingPrizes = [];
                
                // 遍历DOM中现有的奖品项
                $('.prize-item').each(function(index) {
                    var $item = $(this);
                    var prizeData = Controller.api.extractPrizeDataFromDOM($item, index);
                    if (prizeData) {
                        existingPrizes.push(prizeData);
                        console.log('提取到奖品数据:', prizeData);
                    }
                });
                
                // 如果有奖品数据，同步到数据管理器
                if (existingPrizes.length > 0) {
                    Controller.api.prizesDataManager.prizesData = existingPrizes;
                    Controller.api.prizesDataManager.saveToHiddenField();
                    console.log('已同步奖品数据到数据管理器，共', existingPrizes.length, '个奖品');
                } else {
                    console.log('DOM中没有找到现有的奖品数据');
                }
            },
            
            // 从DOM中提取奖品数据
            extractPrizeDataFromDOM: function($item, index) {
                try {
                    var isNoPrize = $item.attr('data-type') === 'no-prize';
                    var prizeData = {
                        id: $item.attr('data-prize-id') || ('prize_' + Date.now() + '_' + index),
                        name: '',
                        type: 1,
                        image: '',
                        quantity: 0,
                        rate: 0
                    };
                    
                    // 提取奖品名称
                    if (isNoPrize) {
                        // 系统默认未中奖项
                        prizeData.name = $item.find('.prize-name-input').val() || $item.find('td:eq(1)').text().trim() || '谢谢参与';
                        prizeData.type = parseInt($item.find('.prize-type-input').val() || 1);
                        prizeData.image = $item.find('.prize-image-input').val() || '';
                        // 如果隐藏域中没有图片，尝试从img标签获取（去掉CDN前缀）
                        if (!prizeData.image) {
                            var imgSrc = $item.find('.prize-image').attr('src') || '';
                            if (imgSrc && typeof Fast !== 'undefined' && Fast.api && Fast.api.cdnurl) {
                                // 去掉CDN前缀，获取相对路径
                                prizeData.image = imgSrc.replace(/^https?:\/\/[^\/]+/, '');
                            } else {
                                prizeData.image = imgSrc;
                            }
                        }
                        prizeData.quantity = 0; // 未中奖项数量固定为0
                        prizeData.rate = parseFloat($item.find('.prize-rate').val() || $item.find('#no-prize-rate-input').val() || 50);
                    } else {
                        // 用户添加的奖品
                        prizeData.name = $item.find('.prize-name').text().trim();
                        prizeData.type = parseInt($item.find('.prize-type-input').val() || 2);
                        prizeData.image = $item.find('.prize-image-input').val() || $item.find('.prize-image').attr('src') || '';
                        prizeData.quantity = parseInt($item.find('.prize-quantity').val() || 1);
                        prizeData.rate = parseFloat($item.find('.prize-rate').val() || 0);
                    }
                    
                    // 根据奖品类型提取特定数据
                    switch(prizeData.type) {
                        case 3: // 积分
                            prizeData.points = parseInt($item.find('.prize-points-input').val() || 0);
                            break;
                        case 4: // 余额
                            prizeData.balance = parseFloat($item.find('.prize-balance-input').val() || 0);
                            break;
                        case 5: // 优惠券
                            prizeData.coupon_id = $item.find('.prize-coupon-id-input').val();
                            prizeData.couponId = prizeData.coupon_id;
                            prizeData.coupon_name = $item.find('.prize-coupon-name').text() || '';
                            break;
                        case 6: // 红包
                            prizeData.redpack_amount = parseFloat($item.find('.prize-redpack-input').val() || 0);
                            break;
                        case 7: // 兑换码
                            prizeData.code_type = $item.find('.prize-code-type-input').val() || 'auto';
                            prizeData.manual_codes = $item.find('.prize-manual-codes-input').val() || '';
                            break;
                        case 8: // 商城奖品
                            prizeData.goods_id = $item.find('.prize-goods-id-input').val();
                            prizeData.goodsId = prizeData.goods_id;
                            prizeData.goods_name = $item.find('.prize-goods-name').text() || '';
                            break;
                    }
                    
                    console.log('提取奖品数据:', {
                        index: index,
                        isNoPrize: isNoPrize,
                        extractedData: prizeData
                    });
                    
                    return prizeData;
                } catch (e) {
                    console.warn('提取奖品数据时出错:', e, $item);
                    return null;
                }
            },
            
            // 初始化已有的奖品数据（重构版 - 使用数据管理器）
            initExistingPrizes: function() {
                // 检查是否有后台传递的奖品数据
                if (typeof window.existingPrizes !== 'undefined' && window.existingPrizes.length > 0) {
                    console.log('正在初始化已有奖品数据:', window.existingPrizes);
                    
                    // 将已有奖品数据加载到数据管理器
                    Controller.api.prizesDataManager.prizesData = window.existingPrizes;
                    Controller.api.prizesDataManager.saveToHiddenField();
                    
                    // 重新构建奖品列表
                    Controller.api.rebuildPrizeList();
                    
                    // 更新奖品计数和概率统计
                    Controller.api.updatePrizeCount();
                    Controller.api.updateTotalRate();
                    
                    console.log('奖品数据初始化完成，数据管理器已同步');
                } else {
                    console.log('没有找到已有的奖品数据，尝试从DOM同步');
                    // 如果没有后台数据，尝试从DOM同步现有数据
                    Controller.api.syncExistingPrizesToDataManager();
                }
            },
            
            // 初始化已有的规则数据
            initExistingRules: function() {
                // 检查是否有后台传递的规则数据
                if (typeof window.existingRulesData !== 'undefined' && window.existingRulesData) {
                    console.log('正在初始化已有规则数据:', window.existingRulesData);
                    
                    // 将已有规则数据加载到数据管理器
                    Controller.api.rulesDataManager.rulesData = window.existingRulesData;
                    Controller.api.rulesDataManager.saveToHiddenField();
                    
                    console.log('规则数据初始化完成');
                } else {
                    console.log('没有找到已有的规则数据');
                }
            },
            
            // 初始化已有的条件数据
            initExistingConditions: function() {
                // 检查是否有后台传递的条件数据
                if (typeof window.existingConditions !== 'undefined' && window.existingConditions.length > 0) {
                    console.log('正在初始化已有条件数据:', window.existingConditions);
                    
                    // 根据条件数据勾选任务类型
                    window.existingConditions.forEach(function(condition) {
                        var checkbox = $('input[name="row[task_type][]"][value="' + condition.type + '"]');
                        if (checkbox.length > 0) {
                            checkbox.prop('checked', true);
                            // 显示对应的任务设置
                            $('#task-setting-' + condition.type).show();
                            
                            // 根据条件类型设置具体的数据
                            switch (parseInt(condition.type)) {
                                case 1: // 购买指定商品
                                    if (condition.goods_ids_array && condition.goods_ids_array.length > 0) {
                                        // 需要调用商品选择API来获取商品详情
                                        Controller.api.loadConditionGoods(condition.type, condition.goods_ids_array);
                                    }
                                    break;
                                case 2: // 单笔订单消费满额
                                case 3: // 单次充值满额
                                case 4: // 活动期间累计消费满额
                                    var amountInput = $('input[name="condition[' + condition.type + '][condition_value]"]');
                                    if (amountInput.length > 0) {
                                        amountInput.val(condition.condition_value);
                                    }
                                    break;
                            }
                        }
                    });
                    
                    console.log('条件数据初始化完成');
                } else {
                    console.log('没有找到已有的条件数据');
                }
            },
            
            // 加载条件中的商品数据
            loadConditionGoods: function(taskType, goodsIds) {
                if (!goodsIds || goodsIds.length === 0) return;
                
                // 调用商品信息API
                $.ajax({
                    url: 'shop/goods/info',
                    type: 'POST',
                    data: {
                        ids: goodsIds.join(',')
                    },
                    dataType: 'json',
                    success: function(ret) {
                        if (ret.code === 1 && ret.data && ret.data.length > 0) {
                            // 更新商品显示
                            Controller.api.updateSelectedGoods(ret.data, {
                                container: '#task-setting-' + taskType + ' #selected-goods',
                                template: 'goods-list-template'
                            });
                            
                            // 更新隐藏字段
                            $('#task-goods-ids-' + taskType).val(JSON.stringify(goodsIds));
                            
                            console.log('任务商品数据加载完成:', ret.data);
                        }
                    },
                    error: function(xhr, status, error) {
                        console.error('加载任务商品数据失败:', error);
                    }
                });
            },           

            
            // 验证任务规则设置
            validateTaskRules: function() {
                var checkedTypes = $('input[name="row[task_type][]"]:checked');
                
                // 检查是否选择了任务类型
                if (checkedTypes.length === 0) {
                    Toastr.error('请选择至少一种参与条件');
                    return false;
                }
                
                // 验证每个选中的任务类型
                var isValid = true;
                checkedTypes.each(function() {
                    var type = parseInt($(this).val());
                    var container = $('#task-setting-' + type);
                    
                    switch(type) {
                        case 1: // 购买指定商品
                            var goodsContainer = container.find('#selected-goods');
                            if (goodsContainer.find('.goods-list-item').length === 0) {
                                Toastr.error('请选择参与的商品');
                                isValid = false;
                                return false;
                            }
                            break;
                            
                        case 2: // 单笔订单消费满额
                        case 3: // 单次充值满额
                        case 4: // 活动期间累计消费满额
                            var amountInput = container.find('input[name*="[condition_value]"]');
                            var amount = parseFloat(amountInput.val()) || 0;
                            if (amount <= 0) {
                                var typeName = type === 2 ? '订单消费' : (type === 3 ? '充值' : '累计消费');
                                Toastr.error('请填写' + typeName + '金额');
                                amountInput.focus();
                                isValid = false;
                                return false;
                            }
                            break;
                    }
                });
                
                return isValid;
            }, 
                       
            // 初始化奖品管理 - 重构版
            initPrizeManagement: function() {
                console.log('初始化奖品管理模块');
                
                // 初始化拖拽排序
                Controller.api.initPrizeSort();
                
                // 初始化概率计算
                Controller.api.updateTotalRate();
                
                // 绑定奖品相关事件
                Controller.api.bindPrizeEvents();
                
                // 初始化表单验证
                Controller.api.initPrizeFormValidation();
                
                console.log('奖品管理模块初始化完成');
            },
            
            // 添加奖品
            addPrize: function() {
                var totalCount = $('.prize-item').length; // 总奖品数（包含未中奖项）
                var userCount = totalCount - 1; // 用户添加的奖品数（减去未中奖项）
                var maxUserCount = 7; // 用户最多只能添加7个奖品（总共8个，包括系统默认的未中奖项）
                
                if (userCount >= maxUserCount) {
                    Toastr.error('最多只能添加' + maxUserCount + '个奖品（不包括系统默认的未中奖项）');
                    return;
                }
                
                // 使用通用表单，添加模式
                Controller.api.openPrizeForm({
                    mode: 'add',
                    title: '添加奖品'
                });
            },
            
            // 初始化奖品表单验证
            initPrizeFormValidation: function() {
                console.log('初始化奖品表单验证');
                
                // FastAdmin使用Nice-validator，验证规则通过data-rule属性定义
                // 无需额外的自定义验证方法，表单验证会在Form.api.bindevent中自动处理
                console.log('FastAdmin表单验证已通过data-rule属性配置');
            },
            
            // 通用奖品表单 - 重构版
            openPrizeForm: function(options) {
                var defaults = {
                    mode: 'add', // 'add' 或 'edit'
                    title: '奖品表单',
                    prizeItem: null,
                    isSystemNoPrize: false,
                    data: {
                        name: '',
                        image: '',
                        type: '2', // 默认实物奖品
                        quantity: '1',
                        rate: '0.00'
                    }
                };
                
                var config = $.extend({}, defaults, options);
                var isEditMode = config.mode === 'edit';
                
                // 获取奖品类型数据
                var prizeTypeMap = Controller.api.parseConfigJson('prizeTypeList', {});
                var prizeTypes = [];
                
                for (var key in prizeTypeMap) {
                    if (prizeTypeMap.hasOwnProperty(key)) {
                        // 添加模式和编辑模式都包含所有类型
                        prizeTypes.push({
                            value: parseInt(key),
                            text: prizeTypeMap[key]
                        });
                    }
                }
                
                // 确定是否显示奖励设置区域
                var selectedType = parseInt(config.data.type) || (isEditMode ? 1 : 2);
                var rewardVisible = selectedType > 2;
                var rewardType = Controller.api.getRewardTypeByPrizeType(selectedType);
                
                // 生成表单HTML - 使用重构的模板
                var formHtml = Template('prize-form-template', {
                    mode: config.mode,
                    prizeTypes: prizeTypes,
                    selectedType: selectedType
                });
                
                // 弹出表单 - 学习提供的样式代码
                Layer.open({
                    type: 1,
                    title: config.title,
                    area: isEditMode ? ['80%', '80%'] : ['80%', '80%'],
                    content: formHtml,
                    btn: [isEditMode ? '保存' : '确定', '取消'],
                    success: function(layero, index) {
                        var $form = layero.find('.prize-form');
                        
                        // 初始化FastAdmin表单组件
                        Form.api.bindevent($form);
                        
                        // 编辑模式需要设置表单数据
                        if (isEditMode) {
                            Controller.api.setFormData($form, config);
                            
                            // 系统默认未中奖项的特殊处理
                            if (config.isSystemNoPrize) {
                                // 隐藏奖品数量字段（未中奖不需要数量）
                                $form.find('.prize-quantity-group').hide();
                                $form.find('[data-favisible="prize_type!=1"]').hide();
                                // 禁用奖品类型选择（固定为未中奖）
                                $form.find('input[name="row[prize_type]"]').prop('disabled', true);
                            }
                        } else {
                            // 添加模式：设置默认奖品类型并触发相应逻辑
                            var defaultType = selectedType || 2; // 默认实物奖品
                            $form.find('input[name="row[prize_type]"][value="' + defaultType + '"]').prop('checked', true);
                            
                            // 设置默认图片
                            Controller.api.setPrizeDefaultImage($form, defaultType);
                            
                            // 触发奖品类型改变事件
                            $form.find('input[name="row[prize_type]"]').trigger('change');
                        }
                        
                        // 设置正确的字数统计初始值
                        var currentName = $form.find('input[name="prize_name"]').val();
                        var currentLength = currentName ? currentName.length : 0;
                        $form.find('#prize-name-count').text(currentLength + '/20');
                        
                        // 绑定自定义事件
                        Controller.api.bindPrizeFormEvents($form, config);
                        
                        // 初始化字数统计
                        Controller.api.initNameCounter($form);
                        
                        // 优化表单样式，使其更紧凑
                        Controller.api.optimizePrizeFormStyle($form);
                        
                        console.log('奖品表单初始化完成');
                    },
                    yes: function(index, layero) {
                        var $form = layero.find('.prize-form');
                        
                        var success = false;
                        if (isEditMode) {
                            success = Controller.api.updatePrize($form, config);
                        } else {
                            success = Controller.api.savePrize($form);
                        }
                        
                        if (success) {
                            Layer.close(index);
                        }
                        
                        // 如果验证失败，success会是false，Layer不会关闭
                        return success;
                    }
                });
            },
            
            // 设置默认表单数据（添加模式）
            setDefaultFormData: function($form, config) {
                console.log('设置默认表单数据');
                
                // 设置默认奖品类型
                var defaultType = config.data.type || 2;
                $form.find('input[name="row[prize_type]"][value="' + defaultType + '"]').prop('checked', true);
                
                // 设置默认图片
                Controller.api.setPrizeDefaultImage($form, defaultType);
                
                // 初始化图片上传组件
                Controller.api.initImageUpload($form);
                
                // 触发奖品类型改变事件
                $form.find('input[name="row[prize_type]"]').trigger('change');
                
                console.log('默认表单数据设置完成');
            },
            
            // 初始化名称字符计数
            initNameCounter: function($form) {
                var $nameInput = $form.find('input[name="prize_name"]');
                var $counter = $form.find('#prize-name-count');
                
                // 初始化计数
                var currentLength = $nameInput.val().length;
                $counter.text(currentLength + '/20');
                
                // 绑定输入事件
                $nameInput.on('input', function() {
                    var length = $(this).val().length;
                    $counter.text(length + '/20');
                });
            },
            
            // 优化奖品表单样式，使其更紧凑
            optimizePrizeFormStyle: function($form) {
                // 减少表单组的间距
                $form.find('.form-group').css({
                    'margin-bottom': '15px'
                });
                
                // 减少奖励设置区域的间距
                $form.find('.reward-group').css({
                    'margin-bottom': '10px'
                });
                
                // 减少表单区块的间距
                $form.find('.form-section').css({
                    'margin-bottom': '20px'
                });
                
                // 减少帮助文本的上边距
                $form.find('.help-block').css({
                    'margin-top': '5px',
                    'margin-bottom': '0px'
                });
                
                // 优化警告框的间距
                $form.find('.alert').css({
                    'margin-top': '10px',
                    'margin-bottom': '10px',
                    'padding': '10px'
                });
                
                // 减少图片预览区域的间距
                $form.find('.plupload-preview').css({
                    'margin-top': '10px'
                });
                
                console.log('表单样式优化完成');
            },
            
            // 初始化图片上传组件
            initImageUpload: function($form) {
                console.log('初始化图片上传组件');
                
                // 使用FastAdmin的Form组件来重新初始化表单内的上传组件
                Form.api.bindevent($form);
                
                // 绑定图片输入框的变化事件，实现预览功能
                $form.find('input[name="prize_image"]').on('change', function() {
                    var imageUrl = $(this).val();
                    if (imageUrl) {
                        // 生成预览HTML
                        var previewHtml = '<li class="col-xs-3">' +
                            '<img src="' + (typeof Fast !== 'undefined' && Fast.api ? Fast.api.cdnurl(imageUrl) : imageUrl) + '" ' +
                            'class="img-responsive img-thumbnail" style="max-width: 100px; max-height: 100px;">' +
                            '</li>';
                        
                        // 更新预览区域
                        $form.find('#p-prize-image').html(previewHtml);
                    } else {
                        // 清空预览
                        $form.find('#p-prize-image').empty();
                    }
                });
                
                console.log('图片上传组件初始化完成');
            },
            
            // 设置表单数据（编辑模式） - 重构版
            setFormData: function($form, config) {
                console.log('设置编辑表单数据', config.data);
                var data = config.data;
                
                // 设置基本字段
                $form.find('input[name="prize_name"]').val(data.name);
                $form.find('input[name="prize_image"]').val(data.image);
                $form.find('input[name="prize_quantity"]').val(data.quantity || '1');
                $form.find('input[name="prize_rate"]').val(parseFloat(data.rate || 0).toFixed(2));
                
                // 设置奖品类型
                $form.find('input[name="row[prize_type]"][value="' + data.type + '"]').prop('checked', true);
                
                // 根据奖品类型处理特殊字段
                switch(parseInt(data.type)) {
                    case 3: // 积分
                        if (data.points) {
                            $form.find('input[name="reward_value_integral"]').val(data.points);
                        }
                        break;
                    case 4: // 余额
                        if (data.balance) {
                            $form.find('input[name="reward_value_balance"]').val(data.balance);
                        }
                        break;
                    case 5: // 优惠券
                        // 支持两种字段名格式
                        var couponId = data.couponId || data.coupon_id;
                        if (couponId) {
                            $form.find('input[name="coupon_id"]').val(couponId);
                            Controller.api.loadCouponInfo($form, couponId);
                        }
                        break;
                    case 6: // 红包
                        if (data.redpack_amount) {
                            $form.find('input[name="reward_value_redpack"]').val(data.redpack_amount);
                        }
                        break;
                    case 7: // 兑换码
                        if (data.code_type) {
                            $form.find('input[name="code_type"][value="' + data.code_type + '"]').prop('checked', true);
                        }
                        if (data.manual_codes) {
                            $form.find('textarea[name="manual_codes"]').val(data.manual_codes);
                        }
                        break;
                    case 8: // 商城奖品
                        // 支持两种字段名格式
                        var goodsId = data.goodsId || data.goods_id;
                        if (goodsId) {
                            $form.find('input[name="goods_id"]').val(goodsId);
                            Controller.api.loadGoodsInfo($form, goodsId);
                        }
                        break;
                }
                
                // 触发奖品类型改变事件以显示对应的奖励设置
                $form.find('input[name="row[prize_type]"]').trigger('change');
                
                // 初始化图片上传组件
                Controller.api.initImageUpload($form);
                
                // 触发图片预览更新
                if (data.image) {
                    $form.find('input[name="prize_image"]').trigger('change');
                }
                
                console.log('编辑表单数据设置完成');
            },
            
            // 绑定奖品表单事件 - 重构版
            bindPrizeFormEvents: function($form, config) {
                console.log('绑定奖品表单事件');
                var isEditMode = config && config.mode === 'edit';
                
                // 奖品类型切换事件
                $form.find('input[name="row[prize_type]"]').off('change.prizeType').on('change.prizeType', function() {
                    var type = parseInt($(this).val());
                    console.log('奖品类型切换至:', type);
                    
                    // 显示/隐藏对应的奖励设置
                    Controller.api.toggleRewardSettings($form, type);
                    
                    // 非编辑模式时设置默认图片
                    if (!isEditMode) {
                        Controller.api.setPrizeDefaultImage($form, type);
                    }
                });
                
                // 商品选择按钮
                $form.find('#select-goods-btn').off('click.selectGoods').on('click.selectGoods', function() {
                    Controller.api.openGoodsSelector($form);
                });
                
                // 优惠券选择按钮
                $form.find('#select-coupon-btn').off('click.selectCoupon').on('click.selectCoupon', function() {
                    Controller.api.openCouponSelector($form);
                });
                
                // 兑换码类型切换
                $form.find('input[name="code_type"]').off('change.codeType').on('change.codeType', function() {
                    var codeType = $(this).val();
                    Controller.api.toggleManualCodesInput($form, codeType);
                });
                
                // 概率输入框格式化
                $form.find('input[name="prize_rate"]').off('blur.rateFormat').on('blur.rateFormat', function() {
                    var value = parseFloat($(this).val()) || 0;
                    $(this).val(value.toFixed(2));
                });
                
                // 删除选中项事件
                $form.find('.selected-display').off('click.removeItem').on('click.removeItem', '.remove-item', function() {
                    var $item = $(this).closest('.selected-item');
                    var $hiddenInput = $item.siblings('input[type="hidden"]');
                    
                    $item.remove();
                    $hiddenInput.val('');
                });
                
                console.log('奖品表单事件绑定完成');
            },
            
            // 切换奖励设置显示
            toggleRewardSettings: function($form, type) {
                console.log('切换奖励设置显示:', type);
                
                // 隐藏所有奖励设置
                $form.find('.reward-group').removeClass('active').hide();
                
                // 根据类型显示对应的设置
                var rewardType = '';
                switch(parseInt(type)) {
                    case 3:
                        rewardType = 'integral';
                        break;
                    case 4:
                        rewardType = 'balance';
                        break;
                    case 5:
                        rewardType = 'coupon';
                        break;
                    case 6:
                        rewardType = 'redpack';
                        break;
                    case 7:
                        rewardType = 'code';
                        break;
                    case 8:
                        rewardType = 'goods';
                        break;
                }
                
                if (rewardType) {
                    $form.find('.reward-group[data-type="' + rewardType + '"]').addClass('active').show();
                }
            },
            
            // 切换手动兑换码输入
            toggleManualCodesInput: function($form, codeType) {
                var $container = $form.find('.manual-codes-container');
                if (codeType === 'manual') {
                    $container.show();
                } else {
                    $container.hide();
                }
            },
            

            
            // 设置奖品默认图片
            setPrizeDefaultImage: function(form, type) {
                // 从后台配置获取默认图片
                var defaultImages = Controller.api.parseConfigJson('prizeDefaultImages', {});
                var defaultImage = defaultImages[type] || '/assets/img/default.png';
                
                // 设置图片路径并触发change事件以更新预览
                form.find('input[name="prize_image"]').val(defaultImage).trigger('change');
            },
            

            
            // 加载商品信息用于编辑模式回显
            loadGoodsInfo: function(form, goodsId, callback) {
                if (!goodsId) {
                    console.warn('loadGoodsInfo: 商品ID为空');
                    if (callback) callback();
                    return;
                }
                
                console.log('正在加载商品信息，ID:', goodsId);
                
                // 通过Ajax获取商品信息
                $.ajax({
                    url: Fast.api.fixurl('shop/goods/info'),
                    type: 'POST',
                    data: {id: goodsId},
                    dataType: 'json',
                    success: function(data) {
                        console.log('商品信息API响应:', data);
                        
                        if (data.code === 1 && data.data) {
                            var goods = data.data; // 标准FastAdmin响应格式
                            console.log('成功获取商品信息:', goods);
                            
                            // 处理商品数据
                            var processedGoods = {
                                id: goods.id,
                                name: goods.name || goods.title,
                                title: goods.title || goods.name,
                                image: goods.image ? Fast.api.cdnurl(goods.image) : '',
                                price: goods.price || goods.sellprice || '',
                                goods_sn: goods.goods_sn || '',
                                spec_type: goods.spec_type !== undefined ? goods.spec_type : null,
                                category: goods.category || null,
                                type_name: Controller.api.getGoodsTypeName(goods),
                                type_text: Controller.api.getGoodsTypeText(goods)
                            };
                            
                            // 使用商品模板显示
                            var html = Template('prize-goods-template', processedGoods);
                            form.find('#selected-goods-display').html(html).show();
                            
                            // 绑定删除事件
                            form.find('.remove-prize-goods').off('click').on('click', function() {
                                $(this).closest('.prize-goods-item').remove();
                                form.find('input[name="goods_id"]').val('');
                            });
                            
                            console.log('商品信息已成功显示');
                            
                            // 执行回调
                            if (callback) callback();
                        } else {
                            console.warn('商品信息API返回异常:', data);
                            // 显示友好的提示信息
                            var errorMsg = data.msg || '获取商品信息失败';
                            form.find('#selected-goods-display').html(
                                '<div class="alert alert-warning" style="margin-top: 10px;">' +
                                '<i class="fa fa-warning"></i> ' + errorMsg + 
                                ' (商品ID: ' + goodsId + ')' +
                                '</div>'
                            ).show();
                            
                            // 即使失败也执行回调
                            if (callback) callback();
                        }
                    },
                    error: function(xhr, status, error) {
                        console.error('加载商品信息失败 - 详细信息:');
                        console.error('- 商品ID:', goodsId);
                        console.error('- HTTP状态:', xhr.status);
                        console.error('- 错误信息:', error);
                        console.error('- 响应内容:', xhr.responseText);
                        
                        // 显示友好的错误提示
                        var errorHtml = '<div class="alert alert-danger" style="margin-top: 10px;">' +
                            '<i class="fa fa-exclamation-circle"></i> 加载商品信息失败<br>' +
                            '<small>商品ID: ' + goodsId + '</small><br>' +
                            '<small>错误: ' + (xhr.status === 404 ? '商品不存在或已删除' : 
                                           xhr.status === 403 ? '无权限访问' : 
                                           '网络错误，请稍后重试') + '</small>' +
                            '</div>';
                        form.find('#selected-goods-display').html(errorHtml).show();
                        
                        // 错误时也执行回调
                        if (callback) callback();
                    }
                });
            },
            
            // 加载优惠券信息用于编辑模式回显
            loadCouponInfo: function(form, couponId) {
                if (!couponId) {
                    console.warn('loadCouponInfo: 优惠券ID为空');
                    return;
                }
                
                console.log('正在加载优惠券信息，ID:', couponId);
                
                // 暂时显示一个简单的占位信息，提醒需要重新选择
                var placeholderHtml = '<div class="alert alert-info" style="margin-top: 10px;">' +
                    '<i class="fa fa-info-circle"></i> 编辑模式下需要重新选择优惠券<br>' +
                    '<small>优惠券ID: ' + couponId + '</small>' +
                    '</div>';
                form.find('#selected-coupon-display').html(placeholderHtml).show();
                
                console.log('优惠券占位信息已显示，用户需要重新选择');
            },
            
            
            // 打开商品选择器
            openGoodsSelector: function(form) {
                Fast.api.open('shop/goods/select?selectMode=single', '选择商品', {
                    callback: function(data) {
                        if (data.length > 0) {
                            var goods = data[0]; // 取第一个选中的商品
                            
                            // 处理商品数据，确保格式完整
                            var processedGoods = {
                                id: goods.id,
                                name: goods.name || goods.title,
                                title: goods.title || goods.name,
                                image: goods.image ? (typeof Fast !== 'undefined' && Fast.api ? Fast.api.cdnurl(goods.image) : goods.image) : '',
                                price: goods.price || goods.sellprice || '',
                                goods_sn: goods.goods_sn || '',
                                spec_type: goods.spec_type !== undefined ? goods.spec_type : null,
                                category: goods.category || null,
                                type_name: Controller.api.getGoodsTypeName(goods),
                                type_text: Controller.api.getGoodsTypeText(goods)
                            };
                            
                            // 使用奖品商品模板
                            var html = Template('prize-goods-template', processedGoods);
                            
                            form.find('#selected-goods-display').html(html).show();
                            
                            // 设置隐藏域的值以触发验证
                            form.find('input[name="goods_id"]').val(goods.id);
                            
                            // 设置商品图片为奖品图片并触发预览更新
                            if (goods.image) {
                                form.find('input[name="prize_image"]').val(goods.image).trigger('change');
                            }
                            
                            // 绑定删除事件
                            form.find('.remove-prize-goods').off('click').on('click', function() {
                                $(this).closest('.prize-goods-item').remove();
                                form.find('input[name="goods_id"]').val(''); // 清空隐藏域
                            });
                        }
                    }
                });
            },
            
            // 打开优惠券选择器
            openCouponSelector: function(form) {
                Fast.api.open('shop/coupon/select', '选择优惠券', {
                    callback: function(data) {
                        if (data.length > 0) {
                            var coupon = data[0]; // 取第一个选中的优惠券
                            
                            // 直接使用模板ID
                            var html = Template('selected-coupon-template', {
                                name: coupon.name,
                                type_text: coupon.type_text || '优惠券',
                                id: coupon.id
                            });
                            
                            form.find('#selected-coupon-display').html(html).show();
                            
                            // 设置隐藏域的值以触发验证
                            form.find('input[name="coupon_id"]').val(coupon.id);
                        }
                    }
                });
            }, 
            
            // 保存奖品 - 重构版（使用数据管理器）
            savePrize: function($form) {
                console.log('开始保存奖品');
                
                // 收集表单数据
                var prizeData = Controller.api.collectPrizeFormData($form);
                if (!prizeData) {
                    return false; // 验证失败
                }
                
                // 使用数据管理器添加奖品
                var prizeId = Controller.api.prizesDataManager.addPrize(prizeData);
                
                // 添加奖品到显示列表（追加模式，不会覆盖现有奖品）
                Controller.api.appendPrizeToList(prizeData);
                
                // 更新相关统计
                Controller.api.updatePrizeCount();
                Controller.api.updateTotalRate();
                
                console.log('奖品保存成功:', prizeData, '奖品ID:', prizeId);
                return true;
            },
            
            // 收集奖品表单数据
            collectPrizeFormData: function($form) {
                console.log('收集奖品表单数据');
                
                var name = $form.find('input[name="prize_name"]').val().trim();
                var type = parseInt($form.find('input[name="row[prize_type]"]:checked').val());
                var image = $form.find('input[name="prize_image"]').val();
                var quantity = parseInt($form.find('input[name="prize_quantity"]').val()) || 1;
                var rate = parseFloat($form.find('input[name="prize_rate"]').val()) || 0;
                
                // 基础验证 - FastAdmin的data-rule已经处理了大部分验证
                // 这里只做简单的空值检查，具体验证错误会由Nice-validator显示
                if (!name) {
                    Toastr.error('请输入奖品名称');
                    return null;
                }
                if (!type) {
                    Toastr.error('请选择奖品类型');
                    return null;
                }
                if (!image) {
                    Toastr.error('请选择奖品图片');
                    return null;
                }
                
                // 构建奖品数据
                var prizeData = {
                    name: name,
                    type: type,
                    image: image,
                    quantity: Controller.api.isNoPrizeType(type) ? 0 : quantity,
                    rate: rate
                };
                
                // 根据奖品类型收集特定数据
                switch(type) {
                    case 3: // 积分
                        prizeData.points = parseInt($form.find('input[name="reward_value_integral"]').val()) || 0;
                        break;
                    case 4: // 余额
                        prizeData.balance = parseFloat($form.find('input[name="reward_value_balance"]').val()) || 0;
                        break;
                    case 5: // 优惠券
                        prizeData.coupon_id = $form.find('input[name="coupon_id"]').val();
                        prizeData.couponId = prizeData.coupon_id; // 为模板提供一致的字段名
                        // 从优惠券显示区域获取名称
                        prizeData.coupon_name = $form.find('#selected-coupon-display').text().trim() || 
                                               $form.find('.selected-coupon-item span:first').text() || '';
                        break;
                    case 6: // 红包
                        prizeData.redpack_amount = parseFloat($form.find('input[name="reward_value_redpack"]').val()) || 0;
                        break;
                    case 7: // 兑换码
                        prizeData.code_type = $form.find('input[name="code_type"]:checked').val() || 'auto';
                        if (prizeData.code_type === 'manual') {
                            prizeData.manual_codes = $form.find('textarea[name="manual_codes"]').val() || '';
                        }
                        break;
                    case 8: // 商城奖品
                        prizeData.goods_id = $form.find('input[name="goods_id"]').val();
                        prizeData.goodsId = prizeData.goods_id; // 为模板提供一致的字段名
                        // 从商品显示区域获取名称
                        prizeData.goods_name = $form.find('#selected-goods-display .goods-name-display').text() || 
                                              $form.find('#selected-goods-display .prize-goods-item .goods-name-display').text() || 
                                              $form.find('.prize-goods-item .goods-name-display').text() || '';
                        break;
                }
                
                console.log('收集到的奖品数据:', prizeData);
                return prizeData;
            },
            
            // 添加奖品到列表（编辑模式用）
            addPrizeToList: function(prize, index) {
                // 获取奖品类型信息
                var typeName = Controller.api.getPrizeTypeName(prize.type);
                var labelClass = Controller.api.getPrizeLabelClass(prize.type);
                var rewardText = Controller.api.getPrizeRewardText(prize);
                
                // 使用传入的索引
                var prizeIndex = typeof index !== 'undefined' ? index : $('.prize-list .prize-item').length;
                
                // 处理图片URL
                var imageRelative = prize.image; // 相对路径，用于表单提交
                var imageDisplay = prize.image ? (typeof Fast !== 'undefined' && Fast.api ? Fast.api.cdnurl(prize.image) : prize.image) : ''; // CDN URL，用于显示
                
                // 判断是否为系统奖品（未中奖类型）
                var isSystemPrize = Controller.api.isNoPrizeType(prize.type);
                
                // 生成唯一的奖品ID
                var prizeId = prize.id || ('prize_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9));
                
                // 使用外部模板 - 重构为仅展示用途
                var prizeHtml = Template('prize-item-template', {
                    index: prizeIndex,
                    prizeId: prizeId,
                    prizeType: isSystemPrize ? 'no-prize' : prize.type, // 系统默认项使用特殊标识
                    name: prize.name,           // 奖品名称
                    description: prize.description || '', // 奖品描述
                    type: prize.type,           // 奖品类型
                    typeName: typeName,         // 类型显示名称
                    labelClass: labelClass,     // 标签样式类
                    rewardText: rewardText,     // 奖励文本
                    imageUrl: imageDisplay,     // CDN URL，用于显示
                    quantity: prize.quantity || 0,  // 奖品数量
                    showQuantity: !Controller.api.isNoPrizeType(prize.type), // 是否显示数量
                    rate: parseFloat(prize.rate || 0).toFixed(2), // 确保概率值格式化为两位小数
                    isSystemPrize: isSystemPrize // 是否为系统奖品
                });
                
                $('.prize-list').append(prizeHtml);
                
                console.log('已添加奖品到列表:', prize.name, '索引:', prizeIndex, '系统奖品:', isSystemPrize, '数据:', prize);
            },
            
            // 添加奖品到列表（新增模式用）- 重构版
            appendPrizeToList: function(prize) {
                // 获取奖品类型信息
                var typeName = Controller.api.getPrizeTypeName(prize.type);
                var labelClass = Controller.api.getPrizeLabelClass(prize.type);
                var rewardText = Controller.api.getPrizeRewardText(prize);
                
                // 获取当前奖品索引，确保与数据管理器中的索引一致
                var prizeIndex = Controller.api.prizesDataManager.prizesData.length - 1;
                
                // 处理图片URL
                var imageDisplay = prize.image ? (typeof Fast !== 'undefined' && Fast.api ? Fast.api.cdnurl(prize.image) : prize.image) : '';
                
                // 生成唯一的奖品ID
                var prizeId = prize.id || ('prize_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9));
                
                // 使用外部模板 - 重构版（仅用于展示）
                var prizeHtml = Template('prize-item-template', {
                    index: prizeIndex,
                    prizeId: prizeId,
                    prizeType: prize.type,      // 奖品类型
                    name: prize.name,           // 奖品名称
                    description: '',            // 奖品描述（新增模式通常为空）
                    type: prize.type,           // 奖品类型
                    typeName: typeName,         // 类型显示名称
                    labelClass: labelClass,     // 标签样式类
                    rewardText: rewardText,     // 奖励文本
                    imageUrl: imageDisplay,     // CDN URL，用于显示
                    quantity: prize.quantity || 0,  // 奖品数量
                    showQuantity: !Controller.api.isNoPrizeType(prize.type), // 是否显示数量
                    rate: parseFloat(prize.rate || 0).toFixed(2), // 确保概率值格式化为两位小数
                    isSystemPrize: false        // 用户添加的奖品非系统奖品
                });
                
                $('.prize-list').append(prizeHtml);
                
                // 重新初始化拖拽排序
                Controller.api.initPrizeSort();
                
                console.log('奖品已追加到列表，索引:', prizeIndex, '数据:', prize);
            },
            

            
            // 初始化默认奖品概率值
            initDefaultPrizeRate: function() {
                console.log('=== 开始初始化奖品概率值 ===');
                
                // 检查整个表格结构
                var prizeTable = $('.prize-list');
                console.log('奖品表格查找结果:', prizeTable.length > 0);
                if (prizeTable.length > 0) {
                    console.log('奖品表格HTML:', prizeTable.html().substring(0, 500) + '...');
                }
                
                // 检查所有概率输入框
                var allRateInputs = $('.prize-rate');
                console.log('找到的所有概率输入框数量:', allRateInputs.length);
                
                // 使用更精确的选择器
                var noPrizeInput = $('#no-prize-rate-input');
                console.log('通过ID查找默认未中奖项输入框:', {
                    found: noPrizeInput.length > 0,
                    value: noPrizeInput.val(),
                    visible: noPrizeInput.is(':visible'),
                    display: noPrizeInput.css('display'),
                    visibility: noPrizeInput.css('visibility')
                });
                
                // 通过class查找
                var noPrizeInputByClass = $('.prize-item[data-type="no-prize"] .prize-rate');
                console.log('通过class查找默认未中奖项输入框:', {
                    found: noPrizeInputByClass.length > 0,
                    value: noPrizeInputByClass.val(),
                    visible: noPrizeInputByClass.is(':visible')
                });
                
                // 检查所有奖品行
                var prizeRows = $('.prize-item');
                console.log('找到的奖品行数量:', prizeRows.length);
                prizeRows.each(function(index) {
                    var $row = $(this);
                    var dataType = $row.attr('data-type');
                    var rateInput = $row.find('.prize-rate');
                    console.log('奖品行 ' + index + ':', {
                        dataType: dataType,
                        hasRateInput: rateInput.length > 0,
                        rateInputValue: rateInput.val(),
                        rateInputVisible: rateInput.is(':visible'),
                        rowHTML: $row.html().substring(0, 200) + '...'
                    });
                });
                
                // 确保系统默认未中奖项有正确的概率值
                var defaultPrizeRateInput = noPrizeInput.length > 0 ? noPrizeInput : noPrizeInputByClass;
                if (defaultPrizeRateInput.length > 0) {
                    var currentValue = defaultPrizeRateInput.val();
                    console.log('当前默认概率值:', currentValue);
                    if (!currentValue || currentValue === '' || parseFloat(currentValue) === 0) {
                        defaultPrizeRateInput.val('50.00');
                        console.log('设置系统默认未中奖项概率为50.00%');
                    }
                    
                    // 强制确保可见性
                    defaultPrizeRateInput.show().css({
                        'display': 'inline-block',
                        'visibility': 'visible',
                        'opacity': '1'
                    });
                } else {
                    console.log('⚠️ 警告: 未找到系统默认未中奖项的概率输入框!');
                    
                    // 尝试创建缺失的输入框
                    var noPrizeRow = $('tr[data-type="no-prize"]');
                    if (noPrizeRow.length > 0) {
                        console.log('找到未中奖行，检查其结构...');
                        var rateTd = noPrizeRow.find('td').eq(5); // 概率列
                        console.log('概率列内容:', rateTd.html());
                        
                        // 如果概率列只有%符号，重新构建
                        if (rateTd.text().trim() === '%') {
                            console.log('发现概率列只有%符号，重新构建input...');
                            rateTd.html(
                                '<div class="input-group" style="width: 100px; margin: 0 auto;">' +
                                '<input type="number" class="form-control input-sm prize-rate text-center" name="prizes[0][rate]" id="no-prize-rate-input" value="50.00" min="0" max="100" step="0.01">' +
                                '<span class="input-group-addon" style="padding: 4px 6px;">%</span>' +
                                '</div>'
                            );
                            console.log('重新构建完成');
                        }
                    }
                }
                
                // 确保所有奖品概率输入框都有默认值
                $('.prize-rate').each(function() {
                    var $this = $(this);
                    var currentValue = $this.val();
                    if (!currentValue || currentValue === '') {
                        if ($this.attr('id') === 'no-prize-rate-input') {
                            $this.val('50.00');
                        } else {
                            $this.val('0.00');
                        }
                    }
                });
                
                // 初始化后更新总概率显示
                Controller.api.updateTotalRate();
                
                console.log('=== 奖品概率值初始化完成 ===');
            },
            
            // 绑定奖品相关事件（使用事件委托）
            bindPrizeEvents: function() {
                // 使用事件委托，避免重复绑定
                $(document).off('input.prizeManagement change.prizeManagement click.prizeManagement');
                
                // 概率输入框事件
                $(document).on('input.prizeManagement', '.prize-rate', function() {
                    var $item = $(this).closest('.prize-item');
                    var index = parseInt($item.attr('data-index'));
                    var rate = parseFloat($(this).val()) || 0;
                    
                    // 更新数据管理器中的数据
                    Controller.api.prizesDataManager.updatePrizeRate(index, rate);
                    
                    // 实时更新总概率
                    Controller.api.updateTotalRate();
                });
                
                $(document).on('change.prizeManagement', '.prize-rate', function() {
                    // 失去焦点时格式化为两位小数
                    var value = parseFloat($(this).val()) || 0;
                    $(this).val(value.toFixed(2));
                    Controller.api.updateTotalRate();
                });
                
                // 奖品数量输入框事件
                $(document).on('input.prizeManagement change.prizeManagement', '.prize-quantity', function() {
                    var $item = $(this).closest('.prize-item');
                    var index = parseInt($item.attr('data-index'));
                    var quantity = parseInt($(this).val()) || 0;
                    
                    // 更新数据管理器中的数据
                    Controller.api.prizesDataManager.updatePrizeQuantity(index, quantity);
                });
                
                // 删除奖品按钮事件
                $(document).on('click.prizeManagement', '.delete-prize', function() {
                    var $item = $(this).closest('.prize-item');
                    var index = parseInt($item.attr('data-index'));
                    
                    // 检查是否是系统默认项
                    if ($item.attr('data-type') === 'no-prize') {
                        Toastr.error('系统默认的未中奖项不能删除');
                        return;
                    }
                    
                    Controller.api.deletePrizeByIndex(index);
                });
                
                // 编辑奖品按钮事件
                $(document).on('click.prizeManagement', '.edit-prize', function() {
                    var $item = $(this).closest('.prize-item');
                    var index = parseInt($item.attr('data-index'));
                    Controller.api.editPrizeByIndex(index);
                });
            },
            
            // 通过索引删除奖品
            deletePrizeByIndex: function(index) {
                // 从数据管理器中删除
                if (Controller.api.prizesDataManager.deletePrize(index)) {
                    // 重新构建列表
                    Controller.api.rebuildPrizeList();
                    
                    // 更新统计
                    Controller.api.updatePrizeCount();
                    Controller.api.updateTotalRate();
                    
                    console.log('奖品已删除，索引:', index);
                }
            },
            
            // 通过索引编辑奖品
            editPrizeByIndex: function(index) {
                var prizeData = Controller.api.prizesDataManager.getPrize(index);
                if (!prizeData) {
                    Toastr.error('奖品数据不存在');
                    return;
                }
                
                // 判断是否为系统默认未中奖项
                var isSystemNoPrize = Controller.api.isNoPrizeType(prizeData.type);
                var title = isSystemNoPrize ? '编辑未中奖项' : '编辑奖品';
                
                // 使用通用表单，编辑模式
                Controller.api.openPrizeForm({
                    mode: 'edit',
                    title: title,
                    prizeIndex: index,
                    isSystemNoPrize: isSystemNoPrize,
                    data: prizeData
                });
            },
            
            // 重新构建奖品列表
            rebuildPrizeList: function() {
                // 清空现有列表
                $('.prize-list').empty();
                
                // 获取所有奖品数据
                var allPrizes = Controller.api.prizesDataManager.getAllPrizes();
                
                // 重新渲染每个奖品
                for (var i = 0; i < allPrizes.length; i++) {
                    Controller.api.addPrizeToList(allPrizes[i], i);
                }
                
                // 重新初始化拖拽排序
                Controller.api.initPrizeSort();
                
                console.log('奖品列表已重新构建');
            },
            
            // 奖品数据管理 - 使用单一JSON隐藏域
            prizesDataManager: {
                // 奖品数据数组
                prizesData: [],
                
                // 初始化奖品数据管理器
                init: function() {
                    // 创建奖品数据隐藏域
                    if ($('#prizes-data-json').length === 0) {
                        $('<input>').attr({
                            type: 'hidden',
                            id: 'prizes-data-json',
                            name: 'prizes_json',
                            value: '[]',
                            'data-rule': 'required;prizesJson',
                            'data-msg-required': '请添加至少一个奖品',
                            'data-msg-prizesJson': '奖品数据格式不正确'
                        }).appendTo('form[role="form"]');
                    }
                    
                    // 初始化数据
                    this.loadFromHiddenField();
                },
                
                // 从隐藏域加载数据
                loadFromHiddenField: function() {
                    var jsonData = $('#prizes-data-json').val();
                    try {
                        this.prizesData = JSON.parse(jsonData || '[]');
                    } catch (e) {
                        this.prizesData = [];
                        console.warn('奖品数据格式错误，已重置为空数组');
                    }
                },
                
                // 保存数据到隐藏域
                saveToHiddenField: function() {
                    var jsonData = JSON.stringify(this.prizesData);
                    $('#prizes-data-json').val(jsonData);
                    console.log('奖品数据已保存到隐藏域:', this.prizesData);
                },
                
                // 添加奖品
                addPrize: function(prizeData) {
                    // 生成唯一ID
                    prizeData.id = 'prize_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
                    this.prizesData.push(prizeData);
                    this.saveToHiddenField();
                    return prizeData.id;
                },
                
                // 更新奖品
                updatePrize: function(index, prizeData) {
                    if (index >= 0 && index < this.prizesData.length) {
                        // 保持原有ID
                        prizeData.id = this.prizesData[index].id;
                        this.prizesData[index] = prizeData;
                        this.saveToHiddenField();
                        return true;
                    }
                    return false;
                },
                
                // 删除奖品
                deletePrize: function(index) {
                    if (index >= 0 && index < this.prizesData.length) {
                        this.prizesData.splice(index, 1);
                        this.saveToHiddenField();
                        return true;
                    }
                    return false;
                },
                
                // 获取奖品数据
                getPrize: function(index) {
                    if (index >= 0 && index < this.prizesData.length) {
                        return this.prizesData[index];
                    }
                    return null;
                },
                
                // 获取所有奖品数据
                getAllPrizes: function() {
                    return this.prizesData;
                },
                
                // 更新奖品数量
                updatePrizeQuantity: function(index, quantity) {
                    if (index >= 0 && index < this.prizesData.length) {
                        this.prizesData[index].quantity = parseInt(quantity) || 0;
                        this.saveToHiddenField();
                        return true;
                    }
                    return false;
                },
                
                // 更新奖品概率
                updatePrizeRate: function(index, rate) {
                    if (index >= 0 && index < this.prizesData.length) {
                        this.prizesData[index].rate = parseFloat(rate) || 0;
                        this.saveToHiddenField();
                        return true;
                    }
                    return false;
                },
                
                // 重新排序奖品
                reorderPrizes: function(newOrder) {
                    var reorderedData = [];
                    for (var i = 0; i < newOrder.length; i++) {
                        var oldIndex = newOrder[i];
                        if (oldIndex >= 0 && oldIndex < this.prizesData.length) {
                            reorderedData.push(this.prizesData[oldIndex]);
                        }
                    }
                    this.prizesData = reorderedData;
                    this.saveToHiddenField();
                }
            },
            
            // 实时更新奖品隐藏域数据（重构版 - 使用奖品数据管理器）
            updatePrizeHiddenFields: function() {
                // 使用奖品数据管理器保存数据
                Controller.api.prizesDataManager.saveToHiddenField();
            },
            
            // 初始化奖品拖拽排序 - 重构版
            initPrizeSort: function() {
                require(['../libs/Sortable/Sortable'], function(Sortable) {
                    var prizeListEl = document.querySelector('.prize-list');
                    if (prizeListEl) {
                        // 如果已经初始化过，先销毁
                        if (prizeListEl.sortableInstance) {
                            prizeListEl.sortableInstance.destroy();
                        }
                        
                        // 创建新的 Sortable 实例
                        prizeListEl.sortableInstance = new Sortable(prizeListEl, {
                            handle: '.prize-sort-handle',
                            animation: 150,
                            onUpdate: function(evt) {
                                // 拖拽排序后重新排列数据管理器中的数据
                                Controller.api.updatePrizeOrderFromDOM();
                            }
                        });
                    }
                });
            },
            
            // 从DOM更新奖品顺序到数据管理器
            updatePrizeOrderFromDOM: function() {
                var newOrder = [];
                $('.prize-list .prize-item').each(function(index) {
                    var oldIndex = parseInt($(this).attr('data-index'));
                    if (!isNaN(oldIndex)) {
                        newOrder.push(oldIndex);
                    }
                });
                
                // 重新排序数据管理器中的数据
                Controller.api.prizesDataManager.reorderPrizes(newOrder);
                
                // 重新构建列表以更新索引
                Controller.api.rebuildPrizeList();
                
                console.log('奖品拖拽排序完成，新顺序:', newOrder);
            },
            
            // 获取奖品类型名称
            getPrizeTypeName: function(type) {
                var prizeTypeMap = Controller.api.parseConfigJson('prizeTypeList', {});
                return prizeTypeMap[type] || '未知';
            },
            
            // 获取奖品标签样式类
            getPrizeLabelClass: function(type) {
                var classMap = {
                    1: 'default',    // 未中奖 - 灰色
                    2: 'primary',    // 实物奖品 - 蓝色
                    3: 'warning',    // 积分 - 橙色
                    4: 'info',       // 余额 - 浅蓝色
                    5: 'success',    // 优惠券 - 绿色
                    6: 'danger',     // 红包 - 红色
                    7: 'default',    // 兑换码 - 灰色
                    8: 'primary'     // 商城奖品 - 蓝色
                };
                return classMap[type] || 'default';
            },
            
            // 获取奖品奖励文本
            getPrizeRewardText: function(prize) {
                if (!prize.type || prize.type == 1) {
                    return ''; // 未中奖不显示奖励文本
                }
                
                switch(parseInt(prize.type)) {
                    case 2: // 实物奖品
                        return '';
                    case 3: // 积分
                        return prize.points ? (prize.points + ' 积分') : '';
                    case 4: // 余额
                        return prize.balance ? (prize.balance + ' 余额') : '';
                    case 5: // 优惠券
                        return prize.coupon_name ? prize.coupon_name : '';
                    case 6: // 红包
                        return prize.redpack_amount ? (prize.redpack_amount + ' 元红包') : '';
                    case 7: // 兑换码
                        return prize.code_type == 'manual' ? '手动兑换码' : '自动兑换码';
                    case 8: // 商城奖品
                        return prize.goods_name ? prize.goods_name : '';
                    default:
                        return '';
                }
            },
            
            // 从表单获取奖品奖励文本
            getPrizeRewardTextFromForm: function(form, type) {
                if (!type || type == 1) {
                    return ''; // 未中奖不显示奖励文本
                }
                
                switch(parseInt(type)) {
                    case 2: // 实物奖品
                        return '';
                    case 3: // 积分
                        var points = form.find('input[name="reward_value_integral"]').val();
                        return points ? (points + ' 积分') : '';
                    case 4: // 余额
                        var balance = form.find('input[name="reward_value_balance"]').val();
                        return balance ? (balance + ' 余额') : '';
                    case 5: // 优惠券
                        // 从优惠券显示区域获取名称
                        var couponName = form.find('#selected-coupon-display').text().trim() || 
                                        form.find('.selected-coupon-item span:first').text();
                        return couponName || '';
                    case 6: // 红包
                        var amount = form.find('input[name="reward_value_redpack"]').val();
                        return amount ? (amount + ' 元红包') : '';
                    case 7: // 兑换码
                        var codeType = form.find('input[name="code_type"]:checked').val();
                        return codeType == 'manual' ? '手动兑换码' : '自动兑换码';
                    case 8: // 商城奖品
                        // 从商品显示区域获取名称
                        return form.find('#selected-goods-display .goods-name-display').text() || 
                               form.find('#selected-goods-display .prize-goods-item .goods-name-display').text() || 
                               form.find('.prize-goods-item .goods-name-display').text() || '';
                    default:
                        return '';
                }
            },
            
            // 根据奖品类型获取奖励类型
            getRewardTypeByPrizeType: function(prizeType) {
                switch(parseInt(prizeType)) {
                    case 3: return 'integral';  // 积分
                    case 4: return 'balance';   // 余额
                    case 5: return 'coupon';    // 优惠券
                    case 6: return 'redbag';    // 红包
                    case 7: return 'code';      // 兑换码
                    case 8: return 'goods';     // 商城奖品
                    default: return 'none';
                }
            },
            
            // 判断是否为未中奖类型
            isNoPrizeType: function(type, element) {
                var typeValue = parseInt(type);
                var isNoPrizeByType = typeValue === 1;
                var isNoPrizeByAttr = element && $(element).attr('data-type') === 'no-prize';
                
                return isNoPrizeByType || isNoPrizeByAttr;
            },
            
            // 更新奖品数量统计
            updatePrizeCount: function() {
                var totalCount = $('.prize-item').length; // 总奖品数（包含未中奖项）
                var userCount = totalCount - 1; // 用户添加的奖品数（减去未中奖项）
                
                console.log('updatePrizeCount - 总奖品数:', totalCount, '用户添加数:', userCount);
                
                // 显示总奖品数（包含系统默认的未中奖项）
                $('#prize-count').text(totalCount);
                
                // 更新添加奖品按钮状态（基于用户可添加的奖品数）
                Controller.api.updateAddPrizeButtonState(userCount);
            },
            
            // 更新添加奖品按钮状态
            updateAddPrizeButtonState: function(userCount) {
                var maxUserCount = 7; // 用户最大可添加奖品数量（总共8个，包括系统默认的未中奖项）
                var addButton = $('#add-prize-btn');
                var remainingCount = maxUserCount - userCount;
                
                console.log('updateAddPrizeButtonState - 用户奖品数:', userCount, '最大允许:', maxUserCount, '剩余:', remainingCount);
                
                if (userCount >= maxUserCount) {
                    // 达到最大数量，禁用按钮
                    addButton.prop('disabled', true).addClass('disabled');
                    addButton.find('.btn-text').text('已达最大数量');
                    $('#prize-count-tip').text('已添加最大数量的奖品').removeClass('text-muted').addClass('text-danger');
                    console.log('按钮已禁用 - 达到最大数量');
                } else {
                    // 未达到最大数量，启用按钮
                    addButton.prop('disabled', false).removeClass('disabled');
                    addButton.find('.btn-text').text('添加奖品');
                    if (remainingCount <= 2) {
                        $('#prize-count-tip').text('还可添加 ' + remainingCount + ' 个奖品').removeClass('text-muted text-danger').addClass('text-warning');
                    } else {
                        // 当用户还没添加奖品时，显示还需添加多少个才能满足最低要求
                        var minRequired = Math.max(0, maxUserCount - userCount); // 需要添加的奖品数量
                        if (minRequired > 0) {
                            $('#prize-count-tip').text('还需添加 ' + minRequired + ' 个奖品').removeClass('text-warning text-danger').addClass('text-muted');
                        } else {
                            $('#prize-count-tip').text('还可添加 ' + remainingCount + ' 个奖品').removeClass('text-warning text-danger').addClass('text-muted');
                        }
                    }
                    console.log('按钮已启用 - 剩余数量:', remainingCount);
                }
            },
            
            // 计算总概率
            calculateTotalRate: function() {
                var total = 0;
                $('.prize-rate').each(function() {
                    total += parseFloat($(this).val()) || 0;
                });
                // 保留两位小数
                return Math.round(total * 100) / 100;
            },
            
            // 更新总概率显示
            updateTotalRate: function() {
                var total = Controller.api.calculateTotalRate();
                // 格式化显示为两位小数
                $('#total-rate').text(total.toFixed(2) + '%');
                
                // 根据概率设置颜色
                if (total > 100) {
                    $('#total-rate').removeClass('text-success text-warning').addClass('text-danger');
                } else if (total === 100) {
                    $('#total-rate').removeClass('text-danger text-warning').addClass('text-success');
                } else {
                    $('#total-rate').removeClass('text-danger text-success').addClass('text-warning');
                }
            },   
              
            // 编辑奖品（统一处理所有类型） - 已弃用，请使用 editPrizeByIndex
            editPrize: function(prizeItem) {
                // 获取奖品索引
                var prizeIndex = parseInt(prizeItem.attr('data-index'));
                if (isNaN(prizeIndex)) {
                    Toastr.error('无法获取奖品索引');
                    return;
                }
                
                // 调用新的编辑方法
                Controller.api.editPrizeByIndex(prizeIndex);
            },
            
            // 更新奖品信息（重构版 - 使用数据管理器）
            updatePrize: function($form, config) {
                console.log('updatePrize 调用参数:', {form: $form, config: config});
                
                // 验证config参数
                if (!config || typeof config !== 'object') {
                    console.error('updatePrize: config参数无效:', config);
                    Toastr.error('配置参数错误');
                    return false;
                }
                
                // 验证prizeIndex
                if (typeof config.prizeIndex === 'undefined' || config.prizeIndex === null) {
                    console.error('updatePrize: prizeIndex参数缺失:', config);
                    Toastr.error('奖品索引参数缺失');
                    return false;
                }
                
                // 收集表单数据
                var prizeData = Controller.api.collectPrizeFormData($form);
                if (!prizeData) {
                    return false; // 验证失败
                }
                
                var prizeIndex = parseInt(config.prizeIndex);
                if (isNaN(prizeIndex) || prizeIndex < 0) {
                    console.error('updatePrize: prizeIndex无效:', config.prizeIndex);
                    Toastr.error('奖品索引无效');
                    return false;
                }
                
                // 使用数据管理器更新奖品
                if (Controller.api.prizesDataManager.updatePrize(prizeIndex, prizeData)) {
                    // 重新构建列表以反映更新
                    Controller.api.rebuildPrizeList();
                    
                    // 更新统计
                    Controller.api.updatePrizeCount();
                    Controller.api.updateTotalRate();
                    
                    console.log('奖品更新成功:', prizeData, '索引:', prizeIndex);
                    return true;
                } else {
                    console.error('updatePrize: 数据管理器更新失败');
                    Toastr.error('更新奖品失败');
                    return false;
                }
            },
            

            

            
            // 在表单提交前收集条件数据 - 已弃用，改为使用规则数据管理器
            collectConditionData: function() {
                // 这个方法已经不再使用，改为使用规则数据管理器
                console.warn('collectConditionData方法已弃用，请使用规则数据管理器');
                
                var conditionData = {};
                var taskTypes = [];
                
                // 获取选中的任务类型
                $('input[name="row[task_type][]"]:checked').each(function() {
                    taskTypes.push($(this).val());
                });
                
                // 为每个任务类型收集条件数据
                taskTypes.forEach(function(taskType) {
                    var type = parseInt(taskType);
                    var condition = {};
                    
                    switch(type) {
                        case 1: // 购买指定商品
                            condition.type = type;
                            condition.goods_rule = $('input[name="condition[' + type + '][goods_rule]"]:checked').val() || 1;
                            condition.goods_ids = $('#task-goods-ids-' + type).val() || '[]';
                            break;
                        case 2: // 单笔订单消费满额
                        case 3: // 单次充值满额
                        case 4: // 活动期间累计消费满额
                            condition.type = type;
                            condition.condition_value = $('input[name="condition[' + type + '][condition_value]"]').val() || 0;
                            break;
                    }
                    
                    conditionData[type] = condition;
                });
                
                return {
                    conditionData: conditionData,
                    taskTypes: taskTypes
                };
            },
            
            // 选择商品 - 通用方法，支持单选和多选
            selectGoods: function(options) {
                var defaults = {
                    mode: 'single', // 'single' 单选, 'multiple' 多选
                    title: '选择商品',
                    container: '#selected-goods',
                    template: 'goods-list-template', // 统一使用goods-list-template
                    maxSelect: 0, // 最大选择数量，0表示无限制
                    callback: null
                };
                
                var config = $.extend({}, defaults, options);
                
                // 构建URL参数
                var urlParams = [];
                
                // 添加选择模式参数
                if (config.mode === 'single') {
                    urlParams.push('selectMode=single');
                } else {
                    urlParams.push('selectMode=multiple');
                    // 如果有最大选择限制，添加参数
                    if (config.maxSelect > 0) {
                        urlParams.push('maxSelect=' + config.maxSelect);
                    }
                }
                
                // 构建完整URL
                var url = 'shop/goods/select';
                if (urlParams.length > 0) {
                    url += '?' + urlParams.join('&');
                }
                
                Fast.api.open(url, config.title, {
                    callback: function(data) {
                        if (data && data.length > 0) {
                            // 单选模式只取第一个
                            if (config.mode === 'single' && data.length > 1) {
                                data = [data[0]];
                            }
                            
                            Controller.api.updateSelectedGoods(data, config);
                            
                            // 执行回调
                            if (typeof config.callback === 'function') {
                                config.callback(data);
                            }
                        } else {
                            Toastr.error('请选择商品');
                        }
                    }
                });
            },
            
            // 选择任务商品（多选模式）
            selectTaskGoods: function(container) {
                Controller.api.selectGoods({
                    mode: 'multiple',
                    title: '选择参与商品',
                    container: container || '#task-goods-container',
                    template: 'task-goods-template',
                    callback: function(data) {
                        // 如果是购买指定商品任务，更新隐藏字段
                        if (container === '#selected-goods' && data && data.length > 0) {
                            var goodsIds = data.map(function(item) {
                                return item.id;
                            });
                            // 更新隐藏字段，存储JSON格式的商品IDs
                            $('#task-goods-ids-1').val(JSON.stringify(goodsIds));
                            console.log('购买指定商品任务 - 商品IDs已更新:', goodsIds);
                            
                            // 绑定删除事件
                            Controller.api.bindTaskGoodsEvents();
                            
                            // 更新规则数据管理器
                            Controller.api.updateRulesDataFromDOM();
                        }
                    }
                });
            },
            
            // 选择奖品商品（单选模式）
            selectPrizeGoods: function(container) {
                Controller.api.selectGoods({
                    mode: 'single',
                    title: '选择奖品商品',
                    container: container || '#prize-goods-container',
                    template: 'goods-list-template' // 使用统一的商品选择模板
                });
            },
            
            // 更新已选商品
            updateSelectedGoods: function(goods, config) {
                config = config || {};
                var container = config.container || '#selected-goods';
                var template = config.template || 'goods-list-template';
                
                // 预处理商品数据
                var processedGoods = Controller.api.processGoodsData(goods);
                
                var html = '';
                
                if (template === 'goods-list-template') {
                    // 商品列表（支持单选和多选）
                    html = Template(template, {
                        goods: processedGoods
                    });
                    
                    $(container).html(html);
                    
                    // 绑定删除事件
                    $('.remove-goods-item').off('click').on('click', function() {
                        $(this).closest('.goods-list-item').remove();
                    });
                    
                } else if (template === 'prize-goods-template') {
                    // 奖品商品（单选）
                    if (processedGoods.length > 0) {
                        html = Template(template, processedGoods[0]);
                        $(container).html(html);
                        
                        // 绑定删除事件
                        $('.remove-prize-goods').off('click').on('click', function() {
                            $(this).closest('.prize-goods-item').remove();
                        });
                    }
                    
                } else {
                    // 其他模板（向后兼容）
                    html = Template(template, {
                        goods: processedGoods
                    });
                    
                    $(container).html(html);
                }
            },
            
            // 处理商品数据
            processGoodsData: function(goods) {
                var processedGoods = [];
                if (goods && goods.length) {
                    for (var i = 0; i < goods.length; i++) {
                        var item = goods[i];
                        var processedItem = {
                            id: item.id,
                            name: item.name || item.title,
                            title: item.title || item.name,
                            image: item.image ? (typeof Fast !== 'undefined' && Fast.api ? Fast.api.cdnurl(item.image) : item.image) : '',
                            price: item.price || item.sellprice || '',
                            goods_sn: item.goods_sn || '',
                            spec_type: item.spec_type !== undefined ? item.spec_type : null,
                            category: item.category || null,
                            type_name: Controller.api.getGoodsTypeName(item),
                            type_text: Controller.api.getGoodsTypeText(item)
                        };
                        processedGoods.push(processedItem);
                    }
                }
                return processedGoods;
            },
            
            // 获取商品类型文本（用于显示标签）
            getGoodsTypeText: function(goods) {
                // 根据商品类型返回相应的标签文本
                if (goods.type == 2) {
                    return '密'; // 虚拟商品显示"密"
                }
                if (goods.isrecom == 1) {
                    return '荐'; // 推荐商品显示"荐"
                }
                if (goods.ishot == 1) {
                    return '热'; // 热门商品显示"热"
                }
                if (goods.isnew == 1) {
                    return '新'; // 新品显示"新"
                }
                return ''; // 默认无标签
            },
            
            // 获取商品类型名称
            getGoodsTypeName: function(goods) {
                // 根据商品类型返回类型名称
                if (goods.type == 1) {
                    return '普通商品';
                } else if (goods.type == 2) {
                    return '虚拟商品';
                } else if (goods.type == 3) {
                    return '服务商品';
                }
                return '普通商品'; // 默认类型
            },
            
            // 绑定任务商品删除事件
            bindTaskGoodsEvents: function() {
                $('.remove-task-goods').off('click').on('click', function() {
                    var goodsId = $(this).data('id');
                    var $item = $(this).closest('.goods-list-item');
                    
                    // 从DOM中移除商品项
                    $item.remove();
                    
                    // 更新隐藏字段中的商品IDs
                    Controller.api.updateTaskGoodsIds();
                    
                    // 更新规则数据管理器
                    Controller.api.updateRulesDataFromDOM();
                });
            },
            
            // 更新任务商品IDs隐藏字段
            updateTaskGoodsIds: function() {
                var goodsIds = [];
                $('#selected-goods .goods-list-item').each(function() {
                    var goodsId = $(this).data('id');
                    if (goodsId) {
                        goodsIds.push(goodsId);
                    }
                });
                
                // 更新隐藏字段
                $('#task-goods-ids-1').val(JSON.stringify(goodsIds));
                console.log('任务商品IDs已更新:', goodsIds);
            },
            
            // 规则数据管理器 - 类似奖品数据管理器
            rulesDataManager: {
                // 规则数据对象
                rulesData: {},
                
                // 初始化规则数据管理器
                init: function() {
                    // 创建规则数据隐藏域
                    if ($('#rules-data-json').length === 0) {
                        $('<input>').attr({
                            type: 'hidden',
                            id: 'rules-data-json',
                            name: 'rules_json',
                            value: '{}',
                            'data-rule': 'required;rulesJson',
                            'data-msg-required': '请设置至少一种参与条件',
                            'data-msg-rulesJson': '规则设置数据格式不正确'
                        }).appendTo('form[role="form"]');
                    }
                    
                    // 初始化数据
                    this.loadFromHiddenField();
                },
                
                // 从隐藏域加载数据
                loadFromHiddenField: function() {
                    var jsonData = $('#rules-data-json').val();
                    try {
                        this.rulesData = JSON.parse(jsonData || '{}');
                    } catch (e) {
                        this.rulesData = {};
                        console.warn('规则数据格式错误，已重置为空对象');
                    }
                },
                
                // 保存数据到隐藏域
                saveToHiddenField: function() {
                    var jsonData = JSON.stringify(this.rulesData);
                    $('#rules-data-json').val(jsonData);
                    console.log('规则数据已保存到隐藏域:', this.rulesData);
                },
                
                // 更新规则数据
                updateRule: function(type, ruleData) {
                    this.rulesData[type] = ruleData;
                    this.saveToHiddenField();
                },
                
                // 删除规则
                deleteRule: function(type) {
                    delete this.rulesData[type];
                    this.saveToHiddenField();
                },
                
                // 获取规则数据
                getRule: function(type) {
                    return this.rulesData[type] || null;
                },
                
                // 获取所有规则数据
                getAllRules: function() {
                    return this.rulesData;
                }
            },
            
            // 收集规则数据并保存到隐藏域
            collectAndSaveRulesData: function() {
                var rulesData = {};
                var taskTypes = [];
                
                // 获取选中的任务类型
                $('input[name="row[task_type][]"]:checked').each(function() {
                    taskTypes.push($(this).val());
                });
                
                // 为每个任务类型收集规则数据
                taskTypes.forEach(function(taskType) {
                    var type = parseInt(taskType);
                    var rule = {
                        type: type
                    };
                    
                    switch(type) {
                        case 1: // 购买指定商品
                            rule.goods_rule = $('input[name="condition[' + type + '][goods_rule]"]:checked').val() || 1;
                            rule.goods_ids = $('#task-goods-ids-' + type).val() || '[]';
                            break;
                        case 2: // 单笔订单消费满额
                        case 3: // 单次充值满额
                        case 4: // 活动期间累计消费满额
                            rule.condition_value = $('input[name="condition[' + type + '][condition_value]"]').val() || 0;
                            break;
                    }
                    
                    rulesData[type] = rule;
                });
                
                // 保存到规则数据管理器
                Controller.api.rulesDataManager.rulesData = rulesData;
                Controller.api.rulesDataManager.saveToHiddenField();
                
                console.log('规则数据已收集并保存:', rulesData);
            },
            
            // 从DOM更新规则数据
            updateRulesDataFromDOM: function() {
                // 在任务类型变化时同步更新规则数据
                Controller.api.collectAndSaveRulesData();
            }
        }
    };
    
    // 全局函数，供HTML调用
    window.addPrize = function() {
        Controller.api.addPrize();
    };
    
    // 默认商品选择（针对购买指定商品任务，使用多选模式）
    window.selectGoods = function() {
        Controller.api.selectGoods({
            mode: 'multiple',
            title: '选择参与商品',
            container: '#selected-goods',
            template: 'goods-list-template'
        });
    };
    
    // 任务商品选择（多选）
    window.selectTaskGoods = function(container) {
        Controller.api.selectTaskGoods(container);
    };
    
    // 奖品商品选择（单选）
    window.selectPrizeGoods = function(container) {
        Controller.api.selectPrizeGoods(container);
    };
    
    // 暴露奖品数据管理器到全局
    window.Controller = Controller;
    
    return Controller;
});