编辑代码

import random

# 菜单数据结构
menu_data = {
    "乡村基": [("乡村基套餐", "由乡村基提供", 0)],
    "杨记北京片皮鸭": [("北京片皮鸭套餐", "由杨记北京片皮鸭提供", 0)],
    "巴咔豆花牛肉": [
        ('ID001', '重庆豆花牛肉套餐', 30),
        ('ID002', '老肉片豆花牛肉套餐', 30),
        ('ID003', '午餐肉豆花牛肉套餐', 30),
        ('ID004', '千层肚豆花牛肉套餐', 30),
        ('ID005', '鲜炸酥肉豆极简牛肉套餐', 30),
        ('ID006', '水晶滑肉豆花牛肉套餐', 30)
    ],
    "71号豆汤饭": {
        "主食系列": [
            ('ID101', '砂锅番茄圆子汤饭', 17.9),
            ('ID102', '砂锅酥肉三鲜豆汤饭', 17.9),
            ('ID103', '招牌砂锅原汤豆汤饭', 15.9),
            ('ID104', '砂锅菌菇鸡汤饭', 18.9)
        ],
        "素菜": [
            ('ID201', '炝拌油麦菜', 6.9),
            ('ID202', '卤拌土豆片', 7.9),
            ('ID203', '酸辣三丝', 7.9),
            ('ID204', '麻辣豆皮', 7.9),
            ('ID205', '功夫土豆片', 7.9),
            ('ID206', '卤拌花菜', 7.9),
            ('ID207', '山椒海带丝', 7.9),
            ('ID208', '剁椒三素拼(三月瓜、白菜、莲白)', 8.9),
            ('ID209', '剁椒莲白', 7.9),
            ('ID210', '剁椒茄子', 8.9),
            ('ID211', '剁椒莴笋条', 7.9),
            ('ID212', '剁椒大白菜', 7.9),
            ('ID213', '卤拌三素拼', 8.9),
            ('ID214', '剁椒三月瓜', 7.9)
        ]
    },
    "炒菜": {
        "三哥家常菜": {
            "荤菜": [
                ('ID301', '回锅肉', 25), 
                ('ID302', '盐煎肉', 25),
                ('极简ID303', '泡椒猪肝', 25),
                ('ID304', '青椒肉丝', 25), 
                ('ID305', '鱼香肉丝', 25),
                ('ID306', '土豆肉丝', 25), 
                ('ID307', '泡椒土豆肉丝', 25),
                ('ID308', '宫爆鸡丁', 25),
                ('ID309', '农家老腊肉', 25), 
                ('ID310', '辣子鸡', 25),
                ('ID311', '软炸平菇', 25),
                ('ID312', '仔姜肉丝', 25),
                ('ID313', '辣子鸡丁', 25), 
                ('ID314', '毛血旺', 25),
                ('ID315', '水煮肉片', 25),
                ('ID316', '香辣大虾', 25),
                ('ID317', '糖醋里脊', 25), 
                ('ID318', '椒盐里脊', 25),
                ('ID319', '京酱肉丝', 25), 
                ('ID320', '南瓜肉丝', 25),
                ('ID321', '白菜肉丝', 25),
                ('ID322', '辣子猪肝', 25), 
                ('ID323', '蒜薹肉丝', 25),
                ('ID324', '泡椒木耳肉丝', 25)
            ],
            "素菜": [
                ('ID401', '麻婆豆腐', 15), 
                ('ID402', '番茄炒蛋', 15),
                ('ID403', '苦瓜炒蛋', 15), 
                ('ID404', '干煸四季豆', 15),
                ('ID405', '肉末茄子', 15), 
                ('ID406', '糖醋白菜', 15),
                ('ID407', '鱼香茄子', 15), 
                ('ID408', '青椒土豆丝', 15),
                ('ID409', '炒时蔬', 15), 
                ('ID410', '杂海椒土豆片', 15),
                ('ID411', '青椒炒蛋', 15), 
                ('ID412', '青椒皮蛋', 15),
                ('ID413', '香油黄瓜', 15), 
                ('ID414', '凉拌豇豆', 15),
                ('ID415', '凉拌三丝', 15), 
                ('ID416', '酸辣土豆丝', 15),
                ('ID417', '炝炒包包白', 15), 
                ('ID418', '韭菜炒蛋', 15),
                ('ID419', '油渣花菜', 15), 
                ('ID420', '炒丝瓜', 15),
                ('ID421', '油渣莲白', 15), 
                ('ID422', '干煸土豆丝', 15),
                ('ID423', '炝炒豆芽', 15), 
                ('ID424', '糖醋藕丁', 15),
                ('ID425', '炝炒藕丁', 15)
            ],
            "汤": [
                ('ID501', '时蔬汤', 15), 
                ('ID502', '番茄鸡蛋汤', 15),
                ('ID503', '黄瓜皮蛋汤', 15)
            ],
            "主食系列": [('ID601', '大米饭', 3)]
        },
        "陈蹄花": {
            "荤菜": [
                ('ID701', '毛血旺', 50.4), 
                ('ID702', '小炒黄牛肉带馍', 53.8),
                ('ID703', '泡椒牛肉丝', 43.8), 
                ('ID704', '尖椒鸡', 43.8),
                ('ID705', '鱼香肉极简丝', 32), 
                ('ID706', '烧椒嫩牛肉', 47.8),
                ('ID707', '陈妈回锅肉', 42), 
                ('ID708', '辣椒炒肉', 38.8),
                ('ID709', '番茄炒鸡蛋', 19.8), 
                ('ID710', '风味仔骨', 49.8),
                ('ID711', '农家蒸烧白', 45), 
                ('ID712', '夹沙肉', 39.8)
            ],
            "素菜": [
                ('ID801', '酸辣土豆丝', 18), 
                ('ID802', '陈府小炒', 19.8),
                ('ID803', '麻婆豆腐', 21), 
                ('ID804', '菜心炒鲜蘑', 22.8),
                ('ID805', '木耳山药', 24), 
                ('ID806', '蒜蓉西兰花', 22),
                ('ID807', '豇豆烧茄子', 24), 
                ('ID808', '烧椒四季豆', 23),
                ('ID809', '锅巴小土豆', 29), 
                ('ID810', '油麦菜', 18)
            ],
            "汤": [
                ('ID901', '番茄丸子汤', 38.8), 
                ('ID902', '养生菌汤', 38),
                ('ID903', '皮蛋黄瓜汤', 18), 
                ('ID904', '青菜豆腐汤', 18)
            ],
            "主食系列": [('ID1001', '大米饭', 3)]
        }
    },
    "火锅串串冒菜": {
        "荤菜": [
            ('ID1101', '鸡肉里脊肉', 25),
            ('ID1102', '滑肉', 25),
            ('ID1103', '老肉片', 25),
            ('ID1104', '牛肉', 25),
            ('ID1105', '撒尿牛肉丸', 25),
            ('ID1106', '鹌鹑蛋', 25),
            ('ID1107', '牛蹄筋', 25),
            ('ID1108', '香菜丸子', 25),
            ('ID1109', '火腿肠', 25),
            ('ID1110', '海霸王虾饺', 25),
            ('ID1111', '虾滑', 25),
            ('ID1112', '三线肉', 25),
            ('ID1113', '毛肚', 25),
            ('ID1114', '菌花', 25)
        ],
        "素菜": [
            ('ID1201', '老南瓜', 12),
            ('ID1202', '冬瓜', 12),
            ('ID1203', '魔芋丝', 12),
            ('ID1204', '海带', 12),
            ('ID1205', '鲜木耳', 12),
            ('ID1206', '豆皮', 12),
            ('ID1207', '莴笋头', 12),
            ('ID1208', '黄瓜条', 12),
            ('ID1209', '土豆', 12),
            ('ID1210', '年糕', 12),
            ('ID1211', '藕片', 12),
            ('ID1212', '鸭血', 12),
            ('ID1213', '山药', 12),
            ('ID1214', '香菇', 12),
            ('ID1215', '干笋', 12),
            ('ID1216', '贡菜', 12),
            ('ID1217', '豆腐', 12),
            ('ID1218', '鱼丸', 12),
            ('ID1219', '鱼排', 12),
            ('ID1220', '腐竹', 12),
            ('ID1221', '苕粉', 12),
            ('ID1222', '黑豆腐', 12),
            ('ID1223', '平菇', 12),
            ('ID1224', '豆干', 12),
            ('ID1225', '豆芽', 12),
            ('ID1226', '香豆腐', 12),
            ('ID1227', '土豆粉', 12)
        ]
    },
    "峨眉烧烤": {
        "江湖菜系列": [
            ('ID1301', '干锅虾(唯一)', 88),
            ('ID1302', '牙签牛肉', 58),
            ('ID1303', '干锅青菜牛肉', 48)
        ],
        "主食系列": [
            ('ID1401', '酱肉丁炒饭', 10),
            ('ID1402', '卤香河粉', 22),
            ('ID1403', '大米饭', 1),
            ('ID1404', '菜炒饭', 15),
            ('ID1405', '蛋炒饭', 15),
            ('ID1406', '成都烫饭', 8)
        ]
    },
    "虾吃虾涮": {
        "干锅": [
            ('ID1501', '招牌虾锅套餐(唯一)', 118),
            ('ID1502', '排骨虾锅套餐(唯一)', 168)
        ],
        "主食系列": [
            ('ID1601', '大米饭', 3),
            ('ID1602', '蛋炒饭', 12)
        ]
    }
}

# 避免相似食材的映射
ingredient_groups = {
    "土豆": {"土豆", "土豆片", "土豆丝", "锅巴小土豆", "干煸土豆丝"},
    "白菜": {"白菜", "大白菜", "包包白", "莲白"},
    "豆腐": {"豆腐", "黑豆腐", "麻婆豆腐", "香豆腐"},
    "蘑菇": {"鲜木耳", "香菇", "平菇", "菌菇"},
    "茄子": {"茄子", "鱼香茄子", "肉末茄子", "豇豆烧茄子"},
    "青菜": {"青菜", "油麦菜", "包包白", "剁椒大白菜", "菜心炒鲜蘑", "时蔬", "韭菜"},
    "猪肉": {"回锅肉", "盐煎肉", "青椒肉丝", "鱼香肉丝", "土豆肉丝"},
    "鸡肉": {"辣子鸡", "辣子鸡丁", "宫爆鸡丁"}
}

def get_ingredient_group(item):
    """获取菜品的食材分组"""
    for group, members in ingredient_groups.items():
        if any(member in item for member in members):
            return group
    # 创建基于菜名的分组
    if "土豆" in item: return "土豆"
    if "豆腐" in item: return "豆腐"
    if "白菜" in item: return "白菜"
    if "蘑菇" in item or "菌" in item or "菇" in item: return "蘑菇"
    if "茄子" in item: return "茄子"
    if "青菜" in item or "菜" in item: return "青菜"
    if "肉" in item: return "猪肉"
    if "鸡" in item: return "鸡肉"
    return item.split(' ')[0]  # 默认返回第一词

class MealGenerator:
    """菜单生成器"""
    def __init__(self):
        self.generated_menu = None
        self.current_category = None
        self.restaurant = None  # 存储当前选择的餐厅
    
    def refresh_menu(self, keep_ids=None):
        """生成或刷新菜单,可选择保留特定菜品"""
        if not self.current_category:
            # 第一次生成,随机选择大类
            categories = list(menu_data.keys())
            self.current_category = random.choice(categories)
        
        # 处理用户选择保留的菜品
        keep_items = []
        used_groups = set()
        if keep_ids and self.generated_menu:
            # 提取保留菜品的信息
            for item in self.generated_menu['items']:
                if item['id'] in keep_ids:
                    keep_items.append({
                        'id': item['id'],
                        'name': item['name'],
                        'price': item['price'],
                        'type': item.get('type', '')
                    })
                    # 记录保留菜品的食材分组
                    group = get_ingredient_group(item['name'])
                    used_groups.add(group)
        
        # 根据不同类别生成菜单
        if self.current_category in ["乡村基", "杨记北京片皮鸭"]:
            self.generated_menu = self._generate_special()
        
        elif self.current_category == "巴咔豆花牛肉":
            self.generated_menu = self._generate_baka(keep_items, used_groups)
        
        elif self.current_category == "71号豆汤饭":
            self.generated_menu = self._generate_doutangfan(keep_items, used_groups)
        
        elif self.current_category == "炒菜":
            # 如果已有餐厅信息则保留,否则随机选择
            if not self.restaurant or not keep_ids:
                self.restaurant = random.choice(list(menu_data["炒菜"].keys()))
            self.generated_menu = self._generate_stirfry(keep_items, used_groups)
        
        elif self.current_category == "火锅串串冒菜":
            self.generated极简_menu = self._generate_hotpot(keep_items, used_groups)
        
        elif self.current_category == "峨眉烧烤":
            self.generated_menu = self._generate_grill(keep_items, used_groups)
        
        elif self.current_category == "虾吃虾涮":
            self.generated_menu = self._generate_shrimp(keep_items, used_groups)
        
        return self.generated_menu
    
    def _generate_special(self):
        """生成乡村基/杨记北京片皮鸭的菜单"""
        item = random.choice(menu_data[self.current_category])
        return {
            'category': self.current_category,
            'items': [{
                'id': 'ID0',
                'name': item[1],
                'price': item[2],
                'description': item[0]
            }],
            'total': item[2]
        }
    
    def _generate_baka(self, keep_items, used_groups):
        """生成巴咔豆花牛肉的菜单"""
        all_items = menu_data["巴咔豆花牛肉"]
        
        # 如果保留了菜品,确保不会重复选择
        selected = []
        if keep_items:
            selected = [(item['id'], item['name'], item['price']) for item in keep_items]
            keep_ids = {item['id'] for item in keep_items}
            available_items = [item for item in all_items if item[0] not in keep_ids]
        else:
            available_items = all_items.copy()
        
        # 随机选择足够的套餐
        num_needed = max(0, 2 - len(selected))
        new_items = random.sample(available_items, min(num_needed, len(available_items)))
        selected += new_items
        
        # 提取菜品详情
        detailed_items = []
        total = 0
        for id, name, price in selected:
            detailed_items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '套餐'
            })
            total += price
        
        return {
            'category': "巴咔豆花牛肉",
            'items': detailed_items,
            'total': total
        }
    
    def _generate_doutangfan(self, keep_items, used_groups):
        """生成71号豆汤饭的菜单"""
        main_courses = menu_data["71号豆汤饭"]["主食系列"]
        veggies = menu_data["71号豆汤饭"]["素菜"]
        
        # 处理保留的菜品
        selected_main = []
        selected_veggie = []
        
        for item in keep_items:
            group = get_ingredient_group(item['name'])
            used_groups.add(group)
            
            # 确定保留菜品类型(主食或素菜)
            if any(item['id'] == main[0] for main in main_courses):
                selected_main.append((item['id'], item['name'], item['price']))
            elif any(item['id'] == veg[0] for veg in veggies):
                selected_veggie.append((item['id'], item['name'], item['price']))
        
        # 确保不会重复选择保留菜品
        keep_ids = {item['id'] for item in keep_items}
        
        # 补充主食
        available_mains = [item for item in main_courses if item[0] not in keep_ids]
        num_mains_needed = 2 - len(selected_main)
        
        if available_mains and num_mains_needed > 0:
            # 尝试找到不冲突的主食
            for item in random.sample(available_mains, len(available_mains)):
                if len(selected_main) >= 2:
                    break
                group = get_ingredient_group(item[1])
                if group not in used_groups:
                    selected_main.append(item)
                    used_groups.add(group)
                    available_mains.remove(item)
            else:
                # 如果没找到不冲突的,随机选择一个
                if available_mains and len(selected_main) < 2:
                    selected_main.append(random.choice(available_mains))
        
        # 补充素菜
        if not selected_veggie:
            available_veggies = [item for item in veggies if item[0] not in keep_ids]
            if available_veggies:
                # 尝试找到不冲突的素菜
                for item in random.sample(available_veggies, len(available_veggies)):
                    group = get_ingredient_group(item[1])
                    if group not in used_groups:
                        selected_veggie.append(item)
                        used_groups.add(group)
                        break
                else:
                    # 如果没找到不冲突的,随机选择一个
                    if available_veggies:
                        selected_veggie.append(random.choice(available_veggies))
        
        # 构建菜品列表
        items = []
        total = 0
        
        for id, name, price in selected_main[:2]:  # 确保最多两个主食
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '主食'
            })
            total += price
        
        for id, name, price in selected_veggie:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '素菜'
            })
            total += price
        
        return {
            'category': "71号豆汤饭",
            'items': items,
            'total': total
        }
    
    def _generate_stirfry(self, keep_items, used_groups):
        """生成炒菜的菜单"""
        food_menu = menu_data["炒菜"][self.restaurant]
        
        # 处理保留的菜品
        selected_meat = []
        selected_veggies = []
        selected_soup = []
        selected_staple = []
        
        # 分类保留的菜品
        for item in keep_items:
            group = get_ingredient_group(item['name'])
            used_groups.add(group)
            
            # 确定菜品类型
            if any(item['id'] == meat[0] for meat in food_menu["荤菜"]):
                selected_meat.append((item['id'], item['name'], item['price']))
            elif any(item['id'] == veg[0] for veg in food_menu["素菜"]):
                selected_veggies.append((item['id'], item['name'], item['price']))
            elif any(item['id'] == soup[0] for soup in food_menu["汤"]):
                selected_soup.append((item['id'], item['name'], item['price']))
            elif any(item['id'] == staple[0] for staple in food_menu["主食系列"]):
                selected_staple.append((item['id'], item['name'], item['price']))
        
        # 确保不会重复选择保留菜品
        keep_ids = {item['id'] for item in keep_items}
        
        # 随机选择套餐类型(只有第一次选择时随机)
        if not keep_items:
            combo_type = random.choice(["AB", "ABC"])
        else:
            # 如果有保留项,保持原有套餐类型
            combo_type = "ABC" if selected_soup else "AB"
        
        # 补充荤菜
        if not selected_meat:
            available_meats = [item for item in food_menu["荤菜"] if item[0] not in keep_ids]
            if available_meats:
                # 尝试找到不冲突的荤菜
                for item in random.sample(available_meats, len(available_meats)):
                    group = get_ingredient_group(item[1])
                    if group not in used_groups:
                        selected_meat.append(item)
                        used_groups.add(group)
                        break
                else:
                    # 如果没找到不冲突的,随机选择一个
                    if available_meats:
                        selected_meat.append(random.choice(available_meats))
        
        # 补充素菜
        available_veggies = [item for item in food_menu["素菜"] if item[0] not in keep_ids]
        num_needed = (1 if combo_type == "ABC" else 2) - len(selected_veggies)
        
        if available_veggies and num_needed > 0:
            new_selected = []
            # 尝试找到不冲突的素菜
            for item in random.sample(available_veggies, len(available_veggies)):
                if len(new_selected) >= num_needed:
                    break
                group = get_ingredient_group(item[1])
                if group not in used_groups:
                    new_selected.append(item)
                    used_groups.add(group)
            
            selected_veggies.extend(new_selected)
        
        # 如果还没满足数量要求,添加随机素菜
        if num_needed > 0 and len(selected_veggies) < num_needed and available_veggies:
            needed = num_needed - len(selected_veggies)
            selected_veggies.extend(random.sample(available_veggies, min(needed, len(available_veggies))))
        
        # 补充汤(如果需要)
        if combo_type == "ABC" and not selected_soup:
            available_soups = [item for item in food_menu["汤"] if item[0] not in keep_ids]
            if available_soups:
                # 尝试找到不冲突的汤
                for item in random.sample(available_soups, len(available_soups)):
                    group = get_ingredient_group(item[1])
                    if group not in used_groups:
                        selected_soup.append(item)
                        used_groups.add(group)
                        break
                else:
                    # 如果没找到不冲突的,随机选择一个
                    if available_soups:
                        selected_soup.append(random.choice(available_soups))
        
        # 补充主食
        if not selected_staple:
            available_staples = [item for item in food_menu["主食系列"] if item[0] not in keep_ids]
            if available_staples:
                selected_staple.append(random.choice(available_staples))
        
        # 构建菜品列表
        items = []
        total = 0
        
        for id, name, price in selected_meat:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '荤菜'
            })
            total += price
        
        for id, name, price in selected_veggies:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '素菜'
            })
            total += price
        
        for id, name, price in selected_soup:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '汤'
            })
            total += price
        
        for id, name, price in selected_staple:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '主食'
            })
            total += price
        
        return {
            'category': f"炒菜({self.restaurant})",
            'items': items,
            'total': total
        }

    def _generate_hotpot(self, keep_items, used_groups):
        """生成火锅串串冒菜的菜单"""
        meats = menu_data["火锅串串冒菜"]["荤菜"]
        veggies = menu_data["火锅串串冒菜"]["素菜"]
        
        # 处理保留的菜品
        selected_meats = []
        selected_veggies = []
        
        for item in keep_items:
            group = get_ingredient_group(item['name'])
            used_groups.add(group)
            
            # 确定菜品类型(荤菜或素菜)
            if any(item['id'] == meat[0] for meat in meats):
                selected_meats.append((item['id'], item['name'], item['price']))
            elif any(item['id'] == veg[0] for veg in veggies):
                selected_veggies.append((item['id'], item['name'], item['price']))
        
        # 确保不会重复选择保留菜品
        keep_ids = {item['id'] for item in keep_items}
        
        # 补充荤菜
        available_meats = [item for item in meats if item[0] not in keep_ids]
        num_meats_needed = max(0, 4 - len(selected_meats))
        
        if available_meats and num_meats_needed > 0:
            # 尝试找到不冲突的荤菜
            new_selected = []
            for item in random.sample(available_meats, min(len(available_meats), num_meats_needed + 10)):
                if len(new_selected) >= num_meats_needed:
                    break
                
                group = get_ingredient_group(item[1])
                if group not in used_groups:
                    new_selected.append(item)
                    used_groups.add(group)
            
            selected_meats.extend(new_selected)
        
        # 补充素菜
        available_veggies = [item for item in veggies if item[0] not in keep_ids]
        num_veggies_needed = max(0, 4 - len(selected_veggies))
        
        if available_veggies and num_veggies_needed > 0:
            new_selected = []
            for item in random.sample(available_veggies, min(len(available_veggies), num_veggies_needed + 10)):
                if len(new_selected) >= num_veggies_needed:
                    break
                
                group = get_ingredient_group(item[1])
                if group not in used_groups:
                    new_selected.append(item)
                    used_groups.add(group)
            
            selected_veggies.extend(new_selected)
        
        # 构建菜品列表
        items = []
        total = 0
        
        for id, name, price in selected_meats[:8]:  # 最多8个荤菜
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '荤菜'
            })
            total += price
        
        for id, name, price in selected_veggies[:8]:  # 最多8个素菜
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '素菜'
            })
            total += price
        
        return {
            'category': "火锅串串冒菜",
            'items': items,
            'total': total
        }

    def _generate_grill(self, keep_items, used_groups):
        """生成峨眉烧烤的菜单"""
        dishes = menu_data["峨眉烧烤"]["江湖菜系列"]
        staples = menu_data["峨眉烧烤"]["主食系列"]
        
        # 处理保留的菜品
        selected_dish = []
        selected_staples = []
        
        for item in keep_items:
            group = get_ingredient_group(item['name'])
            used_groups.add(group)
            
            # 确定菜品类型(江湖菜或主食)
            if any(item['id'] == dish[0] for dish in dishes):
                selected_dish.append((item['id'], item['name'], item['price']))
            elif any(item['id'] == staple[0] for staple in staples):
                selected_staples.append((item['id'], item['name'], item['price']))
        
        # 确保不会重复选择保留菜品
        keep_ids = {item['id'] for item in keep_items}
        
        # 补充江湖菜
        available_dishes = [item for item in dishes if item[0] not in keep_ids]
        if available_dishes and not selected_dish:
            selected_dish.append(random.choice(available_dishes))
        
        # 补充主食
        available_staples = [item for item in staples if item[0] not in keep_ids]
        num_staples_needed = max(0, 2 - len(selected_staples))
        
        if available_staples and num_staples_needed > 0:
            # 主食可以选择相同项
            selected_staples.extend(random.choices(available_staples, k=num_staples_needed))
        
        # 构建菜品列表
        items = []
        total = 0
        
        for id, name, price in selected_dish:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '江湖菜'
            })
            total += price
        
        for id, name, price in selected_staples:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '主食'
            })
            total += price
        
        return {
            'category': "峨眉烧烤",
            'items': items,
            'total': total
        }

    def _generate_shrimp(self, keep_items, used_groups):
        """生成虾吃虾涮的菜单"""
        pots = menu_data["虾吃虾涮"]["干锅"]
        staples = menu_data["虾吃虾涮"]["主食系列"]
        
        # 处理保留的菜品
        selected_pot = []
        selected_staples = []
        
        for item in keep_items:
            group = get_ingredient_group(item['name'])
            used_groups.add(group)
            
            # 确定菜品类型(干锅或主食)
            if any(item['id'] == pot[0] for pot in pots):
                selected_pot.append((item['id'], item['name'], item['price']))
            elif any(item['id'] == staple[0] for staple in staples):
                selected_staples.append((item['id'], item['name'], item['price']))
        
        # 确保不会重复选择保留菜品
        keep_ids = {item['id'] for item in keep_items}
        
        # 补充干锅
        available_pots = [item for item in pots if item[0] not in keep_ids]
        if available_pots and not selected_pot:
            selected_pot.append(random.choice(available_pots))
        
        # 补充主食
        available_staples = [item for item in staples if item[0] not in keep_ids]
        num_staples_needed = max(0, 2 - len(selected_staples))
        
        if available_staples and num_staples_needed > 0:
            # 主食可以选择相同项
            selected_staples.extend(random.choices(available_staples, k=num_staples_needed))
        
        # 构建菜品列表
        items = []
        total = 0
        
        for id, name, price in selected_pot:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '干锅'
            })
            total += price
        
        for id, name, price in selected_staples:
            items.append({
                'id': id,
                'name': name,
                'price': price,
                'type': '主食'
            })
            total += price
        
        return {
            'category': "虾吃虾涮",
            'items': items,
            'total': total
        }

def format_menu(menu_data):
    """格式化菜单输出"""
    output = f"今日食谱: {menu_data['category']}\n"
    output += "=" * 40 + "\n"
    
    for idx, item in enumerate(menu_data['items'], 1):
        item_type = item.get('type', '')
        if item_type:
            item_type = f" ({item_type})"
        output += f"{idx}. {item['name']}{item_type}: {item['price']}元\n"
    
    output += "-" * 40 + "\n"
    output += f"总计: {menu_data['total']:.1f}元"
    return output

def main():
    """主交互程序"""
    print("欢迎使用今日食谱生成器!")
    print("=" * 50)
    
    generator = MealGenerator()
    
    # 首次生成菜单
    menu = generator.refresh_menu()
    print(format_menu(menu))
    
    while True:
        if len(menu['items']) > 1:
            print("\n请输入要保留的菜品编号(多个用逗号分隔,直接回车全部刷新,输入Q退出):")
            keep_input = input().strip().upper()
            
            if keep_input == "Q":
                print("感谢使用,祝您用餐愉快!")
                break
            
            if keep_input:
                try:
                    keep_indexes = [int(idx.strip()) for idx in keep_input.split(",") if idx.strip()]
                    valid_indexes = [idx for idx in keep_indexes if 1 <= idx <= len(menu['items'])]
                    
                    if valid_indexes:
                        # 获取要保留的菜品ID
                        keep_ids = [menu['items'][idx-1]['id'] for idx in valid_indexes]
                        # 刷新其他菜品(保持当前类别)
                        new_menu = generator.refresh_menu(keep_ids)
                        print("\n" + "=" * 50)
                        print("刷新后的菜单(类别保持不变):")
                        print("=" * 50)
                        print(format_menu(new_menu))
                        
                        # 更新当前菜单为刷新后的
                        menu = new_menu
                    else:
                        print("输入无效,没有菜品被保留")
                except ValueError:
                    print("输入格式错误,请使用数字编号,多个用逗号分隔")
            else:
                # 全部刷新(重新选择大类)
                generator.current_category = None
                generator.restaurant = None
                new_menu = generator.refresh_menu()
                print("\n" + "=" * 50)
                print("全新菜单:")
                print("=" * 50)
                print(format_menu(new_menu))
                menu = new_menu
        else:
            print("\n只有一道菜品,不需要刷新。输入Q退出:")
            if input().strip().upper() == "Q":
                print("感谢使用,祝您用餐愉快!")
                break

if __name__ == "__main__":
    main()