app.py

import os
import shutil
import time

import cv2
import base64
import uuid
import re
from flask import Flask
import gradio as gr
from google import genai
from openai import OpenAI as QwenOpenAI


# --- Config 클래스 (Gemma, GPT4o 제거, Qwen만 사용) ---
class Config:
    """애플리케이션 설정 및 상수"""
    FOOD_ITEMS = [
        {"name": "짜장면", "image": "images/food1.jpg", "price": 7.00},
        {"name": "짬뽕", "image": "images/food2.jpg", "price": 8.50},
        {"name": "탕수육", "image": "images/food3.jpg", "price": 15.00},
        {"name": "볶음밥", "image": "images/food4.jpg", "price": 7.50},
        {"name": "깐풍기", "image": "images/food5.jpg", "price": 18.00},
        {"name": "마파두부", "image": "images/food6.jpg", "price": 12.00},
        {"name": "콜라", "image": "images/food6.jpg", "price": 12.00},
        {"name": "사이다", "image": "images/food6.jpg", "price": 12.00},
    ]
    # 알리바바 Qwen API 키 (기본값은 빈 문자열)
    QWEN_API_KEY = "sk-2424f0bd26d64fe5a7f3a2bd407adc76"
    GEMINI_API_key = "AIzaSyCc8lcm2cZo3ZeMgi4QN1IHSvn9BBpLnz4"
    DEFAULT_PROMPT_TEMPLATE = (
        """
        ### Persona ###
        You are an expert tip calculation assistant focusing on service quality observed in video captions, and you also consider the user's review, star rating, and recent Google reviews.
        Your role is to evaluate all these aspects, assign scores, and calculate the overall average score to determine the appropriate tip percentage, with special handling for ethical violations.
    
        ### Task ###
            1.  **Video Analysis**: Analyze the service quality depicted in the provided **Video Caption(s)**. If multiple captions are given, perform a **holistic evaluation** based on the overall impression conveyed by all captions combined. **Focus on significant staff actions, expressions, and interactions described across the captions.** Assign a single, overall **Video Service Score** out of 100 based on this comprehensive analysis, rather than averaging scores from individual captions.
    
            2.  **Bill Amount Determination**: Determine the bill amount by following these steps:
                * Use the 'Calculated Subtotal' provided.
    
            3.  **Overall Service Quality Evaluation**:
                Evaluate the service quality by evenly scoring the following four components, each out of 100:
                    a) **Video Service Score**: Service quality derived from the holistic analysis of Video Caption(s).
                    b) **Google Review Score**: Provide an overall analysis of the recent Google reviews and give the general rating score. Highlight any significant social issues mentioned, such as racist comments or discriminatory behavior. The analysis should consider all reviews collectively.
                       * **Note**: If any review mentions racist, sexist, or any other ethical violations, the Google Review score must automatically be set to **0**.
                    c) **User Review Score**: The user's review.
                    d) **Star Rating Score**: The user's star rating, interpreted on a scale where 5/5 corresponds to 100 points.
                * Calculate the overall average score by taking the mean of these four scores.
    
            4.  **Service Quality Classification and Tip Guidelines**:
                * Based on the overall average score, classify the service quality as follows:
                    * Poor Service: Overall average score < 60 (Tip range: 0% ~ 5% of the bill)
                    * Average Service: Overall average score ≥ 60 and < 80 (Tip range: 10% ~ 15% of the bill)
                    * Good Service: Overall average score ≥ 80 (Tip range: 15% ~ 20% of the bill)
                * Select a specific tip percentage within the appropriate range. **Exception**: If ethical violations were noted (Google Review Score is 0), the Final Tip Percentage **must be 0%**.
                * Calculate the tip amount by multiplying the determined bill amount by the chosen tip percentage (round to two decimal places).
                * Calculate the final total bill by adding the tip amount to the subtotal (round to two decimal places).
    
            5.  **Review Prioritization and Score Adjustment**:
                * Even though all four factors are evaluated equally, if the user's review **explicitly states that specific issues previously mentioned in Google Reviews (especially ethical violations like racism) have been resolved or are no longer present**, then the Google Review score should be adjusted upwards from its potentially reduced value (e.g., from 0 back towards a score reflecting the *current* situation described by the user). The user's direct, specific, and current assessment takes precedence over older or contradicted Google Review points in such cases. Ensure the User Review Score reflects the user's sentiment.
    
        ### Ethical Violations and Tip Adjustment ###
            * If there are any racist, discriminatory, or offensive remarks found in the Google reviews, regardless of the overall review sentiment or scores from other factors, the Google Review Score is automatically set to **0**. Consequently, the **Final Tip Percentage must be set to 0%** to strongly reflect the severity and unacceptability of such behavior.
    
        "### Recent Google Review ###\n\n"

        "#### Google Review 1 ####\n"
        "[4.0 stars] The atmosphere, the taste of the steak, and the service were all good. It was unique and fun to be able to choose after tasting the dessert tea and coffee.   The regrettable points are:  1. The degree of meat cooking must be uniform in the course meal. Everyone has different tastes, but if the degree of cooking must be uniform because it is a course meal, I think I will consider visiting again.  Those who are thinking about a course meal, please take note.  2. When serving all the course meals, they pretended not to notice that they spilled something on the table^^ and when they poured water, they spilled a lot, which was a bit embarrassing.  3. I think they could have explained it more comfortably before serving."
        "\n\n"
        "#### Google Review 2 ####\n"
        "[4.0 stars] A steak restaurant with an American-style atmosphere. Thick tenderloin and strips served? The sound stimulated my appetite, but there was a lot of food, so I left it behind. It was a bit difficult to eat because it was undercooked in the middle. I also had stir-fried kimchi as a garnish, and it was a little sweet, so it tasted like Southeast Asia. The ice cream I had for dessert was delicious, and there was a lot of food left over."
        "\n\n"
    
        ### Video Caption Input ###
        # Multiple captions can be provided under this section
        Video Caption(s):
        {{caption_text}}
    
        ### Output ###
        Return your answer in the exact format below, providing the text analyses first, followed by the JSON block containing the final calculations:
    
        Video Text Analysis: [Provide a summary of the **significant staff actions, expressions, and interactions** observed across all provided **Video Caption(s)**. Explain how these observations contribute to the overall service impression. Include the single, **holistically determined Video Service Score** (out of 100) based on this combined analysis.]
        Recent Google Review Analysis: [Summary of the insights from the Google Reviews, including any negative or racist comments, with the assigned score (out of 100). If ethical violations result in a 0 score, state this clearly.]
        User Review Analysis: [Summary of the user's review including any improvements or enhanced service mentions, with the assigned score (out of 100). Note if this review led to adjustments in the Google Review score based on explicit statements about resolved issues.]
        Star Rating Analysis: [Interpret the user's star rating (e.g., converting 5/5 to 100 points) and include the assigned score (out of 100).]
        Overall Analysis: [Step-by-step explanation detailing:
                   - How the bill amount was determined;
                   - How each of the four components was scored, including the holistic evaluation of video captions and any adjustments made to the Google Review score based on specific user statements about resolved issues;
                   - If any review mentioned racist, sexist, or other ethical violations, explicitly state that the Google Review score was set to 0 and the **Final Tip Percentage is consequently set to 0%**, reflecting the severity;
                   - How the overall average score was calculated;
                   - The reasoning for the final service quality classification based on the average score;
                   - How the final tip percentage was chosen (either based on the guideline range or mandatorily set to 0% due to ethical violations) and the detailed calculation for the tip amount and final total bill.
    
        ### Final Calculation Results (JSON Format) ###
        ```json
        {{{{
          "final_tip_percentage": <calculated_percentage_int>,
          "final_tip_amount": <calculated_tip_float>,
          "final_total_bill": <calculated_total_bill_float>
        }}}}
        ```
    
        ### GUIDE ###
    
        In Final Answer, The ### Final Calculation Results (JSON Format) ### section must strictly follow the JSON structure provided above, containing only the JSON object and its calculated numerical values (use floating-point numbers for all values). **DO NOT include the placeholders like <calculated_percentage_float> in the actual final output; replace them with the real calculated numbers.** Ensure no other special characters like **, $, % are used *within* the JSON structure itself, only standard JSON syntax (keys in double quotes, string values in double quotes, numbers without quotes). The text analysis sections preceding the JSON should still follow their specified format.
        Complete all the text analysis and overall analysis sections first, and generate the ### Final Calculation Results (JSON Format) ### section last.
        **THIS INSTRUCTION ENSURES THAT ONLY THE NECESSARY SPECIAL CHARACTERS THAT ARE PART OF THE REQUIRED OUTPUT FORMAT (E.G., standard JSON syntax) ARE USED, AND ANY OTHER SPECIAL CHARACTERS SUCH AS **, $, %, LATEX COMMANDS, OR ANY NON-STANDARD CHARACTERS SHOULD BE EXCLUDED FROM THE FINAL JSON BLOCK.**
    
        ### User Context ###
            * Current Country: USA
            * Currently Restaurant Name: The Golden Spoon (Assumed)
            * Currently Calculated Subtotal: ${calculated_subtotal:.2f}
            * Currently User Star Rating: {star_rating} / 5 (5 is the maximum)
            * Currently User Review: {user_review}
    
        """
    )

    CUSTOM_CSS = """
    #food-container {
        display: grid;
        grid-template-columns: repeat(3, 1fr);
        gap: 10px;
        overflow-y: auto;
        height: 600px;
    }
    #qwen-button {
        background-color: #8A2BE2 !important;
        color: white !important;
        border-color: #8A2BE2 !important;
    }
    #qwen-button:hover {
        background-color: #7722CC !important;
    }
    """

    def __init__(self):
        if not os.path.exists("images"):
            print("경고: 'images' 폴더를 찾을 수 없습니다. 음식 이미지가 표시되지 않을 수 있습니다.")
        for item in self.FOOD_ITEMS:
            if not os.path.exists(item["image"]):
                print(f"경고: 이미지 파일을 찾을 수 없습니다 - {item['image']}")


# --- ModelClients (알리바바 Qwen API만 사용) ---
class ModelClients:
    def __init__(self, config: Config):
        self.config = config
        from openai import OpenAI as QwenOpenAI
        self.qwen_client = QwenOpenAI(
            api_key=config.QWEN_API_KEY,
            base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
        )
        self.gemini_client = genai.Client(api_key=config.GEMINI_API_key)

    def encode_video_qwen(self, video_path):
        with open(video_path, "rb") as video_file:
            return base64.b64encode(video_file.read()).decode("utf-8")


# --- VideoProcessor: 비디오 프레임 추출 ---
class VideoProcessor:
    def extract_video_frames(self, video_path, output_folder=None, fps=1):
        if not video_path:
            return [], None
        if output_folder is None:
            output_folder = f"frames_list/frames_{uuid.uuid4().hex}"
        os.makedirs(output_folder, exist_ok=True)
        cap = cv2.VideoCapture(video_path)
        if not cap.isOpened():
            print(f"오류: 비디오 파일을 열 수 없습니다 - {video_path}")
            return [], None
        frame_paths = []
        frame_rate = cap.get(cv2.CAP_PROP_FPS)
        if not frame_rate or frame_rate == 0:
            print("경고: FPS를 읽을 수 없습니다, 기본값 4으로 설정합니다.")
            frame_rate = 4.0
        frame_interval = int(frame_rate / fps) if fps > 0 else 1
        if frame_interval <= 0:
            frame_interval = 1
        frame_count = 0
        saved_frame_count = 0
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
            if frame is None:
                print(f"경고: {frame_count}번째 프레임이 비어있습니다.")
                frame_count += 1
                continue
            if frame_count % frame_interval == 0:
                frame_path = os.path.join(output_folder, f"frame_{saved_frame_count}.jpg")
                try:
                    if cv2.imwrite(frame_path, frame):
                        frame_paths.append(frame_path)
                        saved_frame_count += 1
                    else:
                        print(f"경고: {frame_path} 저장 실패.")
                except Exception as e:
                    print(f"경고: 프레임 저장 오류 ({frame_path}): {e}")
            frame_count += 1
        cap.release()
        if not frame_paths:
            print("경고: 프레임 추출 실패.")
            if os.path.exists(output_folder):
                shutil.rmtree(output_folder)
            return [], None
        return frame_paths, output_folder

    def cleanup_temp_files(self, video_path, frame_folder):
        if video_path and "temp_video_" in video_path and os.path.exists(video_path):
            try:
                os.remove(video_path)
                print(f"임시 비디오 파일 삭제: {video_path}")
            except OSError as e:
                print(f"임시 비디오 파일 삭제 오류: {e}")
        if frame_folder and os.path.exists(frame_folder):
            try:
                shutil.rmtree(frame_folder)
                print(f"프레임 폴더 삭제: {frame_folder}")
            except OSError as e:
                print(f"프레임 폴더 삭제 오류: {e}")


# --- TipCalculator (알리바바 Qwen API를 사용한 팁 계산) ---
class TipCalculator:
    def __init__(self, config: Config, model_clients: ModelClients, video_processor: VideoProcessor):
        self.config = config
        self.model_clients = model_clients
        self.video_processor = video_processor

    def parse_llm_output(self, output_text):
        """LLM 출력을 파싱하여 팁 계산 결과 추출"""
        analysis = "Analysis not found."
        tip_percentage = 0.0
        tip_amount = 0.0
        total_bill = 0.0

        # Analysis 부분: "Analysis:" 이후부터 "**Final Tip Percentage**" 이전까지 추출
        analysis_match = re.search(r"Analysis:\s*(.*?)\*\*Final Tip Percentage\*\*", output_text,
                                   re.DOTALL | re.IGNORECASE)
        if analysis_match:
            analysis = analysis_match.group(1).strip()
        else:
            analysis_match_alt = re.search(r"Analysis:\s*(.*)", output_text, re.DOTALL | re.IGNORECASE)
            if analysis_match_alt:
                analysis = analysis_match_alt.group(1).strip()

        # **Final Tip Percentage** 추출 (예: **Final Tip Percentage**: 2.00%)
        percentage_match = re.search(r"\*\*Final Tip Percentage\*\*:\s*([0-9]+(?:\.[0-9]+)?)%", output_text,
                                     re.DOTALL | re.IGNORECASE)
        if percentage_match:
            try:
                tip_percentage = float(percentage_match.group(1))
            except ValueError:
                print(f"경고: Tip Percentage 변환 실패 - {percentage_match.group(1)}")
                tip_percentage = 0.0

        # **Final Tip Amount** 추출 (예: **Final Tip Amount**: $1.44)
        tip_match = re.search(r"\*\*Final Tip Amount\*\*:\s*\$?\s*([0-9]+(?:\.[0-9]+)?)", output_text, re.IGNORECASE)
        if tip_match:
            try:
                tip_amount = float(tip_match.group(1))
            except ValueError:
                print(f"경고: Tip Amount 변환 실패 - {tip_match.group(1)}")
                tip_amount = 0.0
        else:
            print(f"경고: 출력에서 Tip Amount를 찾을 수 없습니다:\n{output_text}")

        # **Final Total Bill** 추출 (예: **Final Total Bill**: $73.44)
        total_match = re.search(r"\*\*Final Total Bill\*\*:\s*\$?\s*([0-9]+(?:\.[0-9]+)?)", output_text, re.IGNORECASE)
        if total_match:
            try:
                total_bill = float(total_match.group(1))
            except ValueError:
                print(f"경고: Total Bill 변환 실패 - {total_match.group(1)}")
        if len(analysis) < 20 and analysis == "Analysis not found.":
            analysis = output_text

        return analysis, tip_percentage, tip_amount, output_text

    def process_tip_qwen(self, video_file_path, star_rating, user_review, calculated_subtotal, custom_prompt=None):
        if not os.path.exists(video_file_path):
            return "Error: 비디오 파일 경로가 유효하지 않습니다.", 0.0, 0.0, [], None, ""
        base64_video = self.model_clients.encode_video_qwen(video_file_path)
        omni_caption_prompt = '''
Task 1: Describe the waiters' actions in these restaurant video frames. Please check for mistakes or negative behaviors.
Task 2: Provide a short chronological summary of the entire scene.
'''
        omni_result = self.model_clients.qwen_client.chat.completions.create(
            model="qwen2.5-omni-7b",
            messages=[
                {
                    "role": "system",
                    "content": [{"type": "text", "text": "You are a helpful assistant."}],
                },
                {
                    "role": "user",
                    "content": [
                        {"type": "video_url", "video_url": {"url": f"data:;base64,{base64_video}"}},
                        {"type": "text", "text": omni_caption_prompt},
                    ],
                },
            ],
            modalities=["text"],
            stream=True,
            stream_options={"include_usage": True},
        )
        all_omni_chunks = list(omni_result)
        caption_text = ""
        for chunk in all_omni_chunks[:-1]:
            if not chunk.choices:
                continue
            if chunk.choices[0].delta.content:
                caption_text += chunk.choices[0].delta.content
        if not caption_text.strip():
            caption_text = "(No caption from Omni)"
        user_review = user_review.strip() if user_review else "(No user review)"
        if custom_prompt is None:
            prompt = self.config.DEFAULT_PROMPT_TEMPLATE.format(
                calculated_subtotal=calculated_subtotal,
                star_rating=star_rating,
                user_review=user_review
            )
        else:
            try:
                prompt = custom_prompt.format(
                    calculated_subtotal=calculated_subtotal,
                    star_rating=star_rating,
                    user_review=user_review
                )
            except:
                prompt = self.config.DEFAULT_PROMPT_TEMPLATE.format(
                    calculated_subtotal=calculated_subtotal,
                    star_rating=star_rating,
                    user_review=user_review
                )
        final_prompt = prompt.replace("{caption_text}", caption_text)
        qvq_result = self.model_clients.qwen_client.chat.completions.create(
            model="qwen2.5-vl-32b-instruct",
            messages=[
                {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant."}]},
                {"role": "user", "content": [{"type": "text", "text": final_prompt}]},
            ],
            modalities=["text"],
            stream=True,
        )
        all_qvq_chunks = list(qvq_result)
        final_reasoning = ""
        final_answer = ""
        is_answering = False
        for c in all_qvq_chunks[:-1]:
            if not c.choices:
                continue
            d = c.choices[0].delta
            if hasattr(d, "reasoning_content") and d.reasoning_content:
                final_reasoning += d.reasoning_content
            if d.content:
                if not is_answering:
                    print("\n" + "=" * 20 + "Complete Response" + "=" * 20 + "\n")
                    is_answering = True
                final_answer += d.content
        final_text = final_reasoning + "\n" + final_answer
        analysis, tip_percentage, tip_amount, output_text = self.parse_llm_output(final_text)
        return analysis, tip_percentage, tip_amount, [], None, output_text

    def process_tip_gemini(self, video_file_path, star_rating, user_review, calculated_subtotal, custom_prompt=None):

        if not video_file_path or not os.path.exists(video_file_path):
            return "비디오 파일 경로가 유효하지 않습니다.", [], None
        image_captioning_prompt = '''
        Task 1: Describe the actions of any waiters or staff visible in these restaurant video. Note any specific interactions, mistakes, or positive actions.
        Task 2: Provide a concise overall summary of the scene depicted in the frames, in chronological order if possible.

        Task 1 Output:
        Task 2 Output:
        '''

        video_file = self.model_clients.gemini_client.files.upload(file=video_file_path)
        print(f"Uploaded file info: {video_file}")

        # 동영상은 처리 중(Processing) 상태이므로, ACTIVE 상태가 될 때까지 대기합니다.
        while video_file.state.name == "PROCESSING":
            print("동영상 처리 중...")
            time.sleep(1)  # 예: 5초마다 상태 점검
            video_file = self.model_clients.gemini_client.files.get(name=video_file.name)

        # 처리 실패 여부 확인
        if video_file.state.name == "FAILED":
            raise ValueError(f"파일 처리 실패: {video_file.state.name}")

        # 비디오를 프롬프트에 포함해서 추론 요청
        try:
            caption_summary = self.model_clients.gemini_client.models.generate_content(
                model="gemini-2.0-flash-lite",  # 예시: Gemini 2.0 Flash 모델 사용
                contents=[video_file, image_captioning_prompt]
            )
            caption_summary = caption_summary.text

        except Exception as e:
            print(f"로컬 모델 프레임 처리 오류: {e}")
            return f"Error in processing frames with local model: {e}", None, None

        user_review = user_review.strip() if user_review and user_review.strip() else "(No user review provided)"

        if custom_prompt is None:
            prompt = self.config.DEFAULT_PROMPT_TEMPLATE.format(
                calculated_subtotal=calculated_subtotal, star_rating=star_rating, user_review=user_review
            )
        else:
            try:
                prompt = custom_prompt.format(
                    calculated_subtotal=calculated_subtotal, star_rating=star_rating, user_review=user_review
                )
            except KeyError as e:
                print(f"경고: 커스텀 프롬프트에 필요한 키가 없습니다: {e}. 기본 템플릿을 사용합니다.")
                prompt = self.config.DEFAULT_PROMPT_TEMPLATE.format(
                    calculated_subtotal=calculated_subtotal, star_rating=star_rating, user_review=user_review
                )

        final_prompt = prompt.replace("{caption_text}", caption_summary)
        messages = final_prompt

        video_file = self.model_clients.gemini_client.files.upload(file=video_file_path)
        print(f"Uploaded file info: {video_file}")

        # 동영상은 처리 중(Processing) 상태이므로, ACTIVE 상태가 될 때까지 대기합니다.
        while video_file.state.name == "PROCESSING":
            print("동영상 처리 중...")
            time.sleep(1)  # 예: 5초마다 상태 점검
            video_file = self.model_clients.gemini_client.files.get(name=video_file.name)

        # 처리 실패 여부 확인
        if video_file.state.name == "FAILED":
            raise ValueError(f"파일 처리 실패: {video_file.state.name}")


        response = self.model_clients.gemini_client.models.generate_content(
            model="gemini-2.0-flash-lite",  # 예시: Gemini 2.0 Flash 모델 사용
            contents=[video_file, messages]
        )
        llm_output = response.text
        analysis, tip_percentage, tip_amount, output_text = self.parse_llm_output(llm_output)
        return analysis, tip_percentage, tip_amount, [], None, output_text


    def calculate_manual_tip(self, tip_percent, subtotal):
        tip_amount = subtotal * (tip_percent / 100)
        total_bill = subtotal + tip_amount
        analysis_output = f"Manual calculation using fixed tip percentage of {tip_percent}%."
        tip_output = f"${tip_amount:.2f} ({tip_percent:.1f}%)"
        total_bill_output = f"${total_bill:.2f}"
        return analysis_output, tip_output, total_bill_output


# --- UIHandler: Gradio 인터페이스 이벤트 처리 (알리바바 API 키 입력 포함) ---
class UIHandler:
    def __init__(self, config: Config, tip_calculator: TipCalculator, video_processor: VideoProcessor):
        self.config = config
        self.tip_calculator = tip_calculator
        self.video_processor = video_processor

    def update_subtotal_and_prompt(self, *args):
        num_food_items = len(self.config.FOOD_ITEMS)
        quantities = args[:num_food_items]
        star_rating = args[num_food_items]
        user_review = args[num_food_items + 1]
        calculated_subtotal = 0.0
        for i in range(num_food_items):
            calculated_subtotal += self.config.FOOD_ITEMS[i]['price'] * quantities[i]
        user_review_text = user_review.strip() if user_review and user_review.strip() else "(No user review provided)"
        updated_prompt = self.config.DEFAULT_PROMPT_TEMPLATE.format(
            calculated_subtotal=calculated_subtotal,
            star_rating=star_rating,
            user_review=user_review_text
        )
        updated_prompt = updated_prompt.replace("{caption_text}", "{{caption_text}}")
        return calculated_subtotal, updated_prompt

    def compute_tip(self, type, video_file_obj, subtotal, star_rating, user_review, custom_prompt_text):
        analysis_output = "계산을 시작합니다..."
        tip_percentage = 0.0
        tip_output = "$0.00"
        total_bill_output = f"${subtotal:.2f}"
        if video_file_obj is None:
            return "오류: 비디오 파일을 업로드해주세요.", "$0.00", total_bill_output, custom_prompt_text, gr.update(value=None)
        try:
            temp_video_path = f"temp_video_{uuid.uuid4().hex}.mp4"
            original_path = video_file_obj.name if hasattr(video_file_obj, 'name') else video_file_obj
            shutil.copyfile(original_path, temp_video_path)
            print(f"임시 비디오 파일 생성: {temp_video_path}")
        except Exception as e:
            print(f"임시 비디오 파일 생성 오류: {e}")
            return f"오류: 비디오 파일을 처리할 수 없습니다: {e}", "$0.00", total_bill_output, custom_prompt_text, None
        frame_folder = None
        try:
            if type == 'qwen':
                analysis, tip_percentage, tip_amount, _, _, output_text = self.tip_calculator.process_tip_qwen(
                    temp_video_path, star_rating, user_review, subtotal, custom_prompt_text
                )
            else:
                analysis, tip_percentage, tip_amount, _, _, output_text = self.tip_calculator.process_tip_gemini(
                    temp_video_path, star_rating, user_review, subtotal, custom_prompt_text
                )
            if "Error" in analysis:
                analysis_output = analysis
                tip_amount = 0.0
            else:
                analysis_output = f"Tip Percentage: {tip_percentage:.1f}%\n\n{output_text}"
                tip_output = f"${tip_amount:.2f} ({tip_percentage:.1f}%)"
                total_bill = subtotal + tip_amount
                total_bill_output = f"${total_bill:.2f}"
        except Exception as e:
            print(f"팁 계산 중 오류 발생 (qwen): {e}")
            analysis_output = f"오류 발생: {e}"
            tip_output = "$0.00"
            total_bill_output = f"${subtotal:.2f}"
        finally:
            self.video_processor.cleanup_temp_files(temp_video_path, frame_folder)
        return analysis_output, tip_output, total_bill_output, custom_prompt_text, gr.update(value=None)

    def auto_tip_and_invoice(self, type, video_file_obj, subtotal, star_rating, review, prompt, *quantities):
        analysis, tip_disp, total_bill_disp, prompt_out, vid_out = self.compute_tip(
            type, video_file_obj, subtotal, star_rating, review, prompt
        )
        invoice = self.update_invoice_summary(*quantities, tip_disp, total_bill_disp)
        return analysis, tip_disp, total_bill_disp, prompt_out, vid_out, invoice

    def update_invoice_summary(self, *args):
        num_items = len(self.config.FOOD_ITEMS)
        quantities = args[:num_items]
        if len(args) >= num_items + 2:
            tip_str = args[num_items]
            total_bill_str = args[num_items + 1]
        else:
            tip_str = "$0.00"
            total_bill_str = "$0.00"
        summary = ""
        for i, q in enumerate(quantities):
            try:
                q_val = float(q)
            except:
                q_val = 0
            if q_val > 0:
                item = self.config.FOOD_ITEMS[i]
                total_price = item['price'] * q_val
                summary += f"{item['name']} x{int(q_val)} : ${total_price:.2f}\n"
        if summary == "":
            summary = "주문한 메뉴가 없습니다."
        summary += f"\nTip: {tip_str}\nTotal Bill: {total_bill_str}"
        return summary

    def manual_tip_and_invoice(self, tip_percent, subtotal, *quantities):
        analysis, tip_disp, total_bill_disp = self.tip_calculator.calculate_manual_tip(tip_percent, subtotal)
        invoice = self.update_invoice_summary(*quantities, tip_disp, total_bill_disp)
        return analysis, tip_disp, total_bill_disp, invoice

    def process_payment(self, total_bill):
        return f"{total_bill} 결제되었습니다."


# --- App: 모든 컴포넌트 연결 및 Gradio 인터페이스 실행 ---
class App:
    def __init__(self):
        self.config = Config()
        self.model_clients = ModelClients(self.config)
        self.video_processor = VideoProcessor()
        self.tip_calculator = TipCalculator(self.config, self.model_clients, self.video_processor)
        self.ui_handler = UIHandler(self.config, self.tip_calculator, self.video_processor)
        self.flask_app = Flask(__name__)

    def create_gradio_blocks(self):
        with gr.Blocks(title="Video Tip Calculation Interface", theme=gr.themes.Soft(),
                       css=self.config.CUSTOM_CSS) as interface:
            gr.Markdown("## Video Tip Calculation Interface (Structured)")

            # --- 컴포넌트 변수 선언 (탭 구조 안에서 정의될 것임) ---
            # 이 변수들은 아래 탭 내부에서 실제 컴포넌트에 할당됩니다.
            quantity_inputs = []
            subtotal_display = gr.Number(label="Subtotal ($)", value=0.0, interactive=False, visible=False)
            subtotal_visible_display_output = None
            review_input, rating_input = None, None
            btn_5, btn_10, btn_15, btn_20, btn_25 = None, None, None, None, None
            qwen_btn = None
            gemini_btn = None
            tip_display, total_bill_display, payment_btn, payment_result = None, None, None, None
            video_input = None
            analysis_display, order_summary_display = None, None
            prompt_editor = None  # 프롬프트 에디터는 다른 탭에 정의될 것임

            # --- 최상위 레벨에 탭 구성 ---
            with gr.Tabs():
                # --- 탭 1: 메인 인터페이스 (원래 레이아웃 유지) ---
                with gr.TabItem("Main Interface"):
                    # 이 탭 안에 원래의 2단 레이아웃을 그대로 재현
                    with gr.Row():
                        # --- 왼쪽 열 (원래대로) ---
                        with gr.Column(scale=2):
                            gr.Markdown("### 1. Select Food Items")
                            with gr.Column(elem_id="food-container"):
                                for item in self.config.FOOD_ITEMS:
                                    with gr.Column():
                                        gr.Image(value=item["image"], label=None, show_label=False, width=150,
                                                 height=150, interactive=False)
                                        gr.Markdown(f"**{item['name']}** (${item['price']:.2f})")
                                        q_input = gr.Number(label="Qty", value=0, minimum=0, step=1,
                                                            elem_id=f"qty_{item['name'].replace(' ', '_')}")
                                        quantity_inputs.append(q_input)

                            gr.Markdown("### Subtotal")
                            subtotal_visible_display_output = gr.Textbox(value="$0.00", label="Subtotal",
                                                                         interactive=False)

                            gr.Markdown("### 2. Service Feedback")
                            review_input = gr.Textbox(label="Review", placeholder="서비스 리뷰 작성", lines=3)
                            rating_input = gr.Radio(choices=[1, 2, 3, 4, 5], value=3, label="⭐Star Rating (1-5)⭐",
                                                    type="value")

                            gr.Markdown("### 3. Calculate Tip (Manual)")
                            with gr.Row():
                                btn_5 = gr.Button("5%")
                                btn_10 = gr.Button("10%")
                                btn_15 = gr.Button("15%")
                                btn_20 = gr.Button("20%")
                                btn_25 = gr.Button("25%")
                            with gr.Row():
                                # Qwen 버튼 정의를 여기로 이동!
                                gemini_btn = gr.Button("Google-Gemini AI Tip Calculation", variant="primary",
                                                     elem_id="Gemini-button")
                                qwen_btn = gr.Button("Alibaba-Qwen AI Tip Calculation", variant="primary",
                                                     elem_id="qwen-button")
                            gr.Markdown("### 4. Results")
                            tip_display = gr.Textbox(label="Calculated Tip", value="$0.00", interactive=False)
                            total_bill_display = gr.Textbox(label="Total Bill (Subtotal + Tip)", value="$0.00",
                                                            interactive=False)
                            payment_btn = gr.Button("결제하기")
                            payment_result = gr.Textbox(label="Payment Result", value="", interactive=False)

                        # --- 오른쪽 열 (원래대로, 프롬프트 디스플레이 제외) ---
                        with gr.Column(scale=1):
                            gr.Markdown("### 5. Upload & Prompt Access")

                            video_input = gr.Video(label="Upload Service Video")

                            gr.Markdown("### 6. AI Analysis")
                            analysis_display = gr.Textbox(label="AI Analysis", lines=8, max_lines=12, interactive=False)

                            gr.Markdown("### 7. 청구서")
                            order_summary_display = gr.Textbox(label="청구서", value="주문 메뉴 없음", lines=8, max_lines=12,
                                                               interactive=False)


                # --- 탭 2: 프롬프트 편집 전용 (넓게!) ---
                with gr.TabItem("Edit Prompt"):
                    gr.Markdown("### Prompt Editor")
                    gr.Markdown("자동 생성된 프롬프트를 여기서 확인하고 **직접 수정**할 수 있습니다. AI 분석 시 여기에 있는 최종 내용이 사용됩니다.")
                    # 이 탭에는 프롬프트 편집기만 배치하여 가로 너비를 최대한 활용
                    prompt_editor = gr.Code(
                        label="Tip Calculation Prompt (Editable)",
                        language="python",  # 하이라이팅이 필요 없으면 "text"
                        value="Loading prompt...",
                        lines=35,  # 세로 높이
                        interactive=True,
                    )

                gr.Examples(
                    examples=[
                        # 입력 순서: [Alibaba API Key, Video, Subtotal, Star Rating, Review] + [각 음식의 Qty]
                        ["video/sample.mp4", 0.0, 1, "He drop the tray..so bad", 0, 0, 0, 0, 0, 2, 0, 0],
                        ["video/sample2.mp4", 0.0, 5, "Good service!", 0, 0, 0, 0, 0, 2, 0, 0]
                    ],
                    inputs=[video_input, subtotal_display, rating_input,
                            review_input] + quantity_inputs,
                    outputs=[analysis_display, tip_display, total_bill_display, video_input, order_summary_display],
                    label="Example: Bad Service, Good Service"
                )

            # --- 이벤트 핸들러 연결 ---
            # 컴포넌트들이 모두 정의된 후에 연결해야 함
            # (실제 코드에서는 컴포넌트 None 체크 또는 더 나은 구조화 필요)

            if all([subtotal_display, subtotal_visible_display_output, review_input, rating_input, prompt_editor,
                    order_summary_display, video_input, analysis_display, tip_display,
                    total_bill_display, payment_result, qwen_btn, gemini_btn] + quantity_inputs):

                # 1. 소계 업데이트 (숨겨진 Number -> 보이는 Textbox)
                subtotal_display.change(
                    fn=lambda x: f"${x:.2f}",
                    inputs=subtotal_display,
                    outputs=subtotal_visible_display_output
                )

                # 2. 입력 변경 시 -> 소계 계산 및 프롬프트 편집기('Edit Prompt' 탭) 업데이트
                inputs_for_prompt_update = quantity_inputs + [rating_input, review_input]
                outputs_for_prompt_update = [subtotal_display, prompt_editor]  # 숨겨진 소계와 다른 탭의 프롬프트 에디터
                for comp in inputs_for_prompt_update:
                    comp.change(
                        fn=self.ui_handler.update_subtotal_and_prompt,
                        inputs=inputs_for_prompt_update,
                        outputs=outputs_for_prompt_update
                    )

                # 3. 수량 변경 시 -> 청구서('Main Interface' 탭) 업데이트
                for comp in quantity_inputs:
                    comp.change(
                        fn=self.ui_handler.update_invoice_summary,
                        inputs=quantity_inputs,
                        outputs=order_summary_display
                    )

                # 4. AI 계산 버튼('Main Interface' 탭) 클릭 시
                # 입력: 메인 탭의 컴포넌트들 + 'Edit Prompt' 탭의 prompt_editor
                # 출력: 메인 탭의 컴포넌트들 + 'Edit Prompt' 탭의 prompt_editor (업데이트 될 수 있으므로)
                qwen_btn.click(
                    fn=lambda vid, sub, rat, rev, prom, *qty: self.ui_handler.auto_tip_and_invoice('qwen', vid, sub,
                                                                                                   rat, rev, prom,
                                                                                                   *qty),
                    inputs=[video_input, subtotal_display, rating_input, review_input, prompt_editor] + quantity_inputs,
                    outputs=[analysis_display, tip_display, total_bill_display, prompt_editor, video_input,
                             order_summary_display]
                )
                gemini_btn.click(
                    fn=lambda vid, sub, rat, rev, prom, *qty: self.ui_handler.auto_tip_and_invoice('gemini', vid, sub,
                                                                                                   rat, rev, prom,
                                                                                                   *qty),
                    inputs=[video_input, subtotal_display, rating_input, review_input, prompt_editor] + quantity_inputs,
                    outputs=[analysis_display, tip_display, total_bill_display, prompt_editor, video_input,
                             order_summary_display]
                )

                # 5. 수동 팁 버튼('Main Interface' 탭) 클릭 시
                manual_tip_outputs = [analysis_display, tip_display, total_bill_display, order_summary_display]
                if btn_5: btn_5.click(fn=lambda sub, *qty: self.ui_handler.manual_tip_and_invoice(5, sub, *qty),
                                      inputs=[subtotal_display] + quantity_inputs, outputs=manual_tip_outputs)
                # ... (btn_10, btn_15, btn_20, btn_25 에 대해서도 동일하게)
                if btn_10: btn_10.click(fn=lambda sub, *qty: self.ui_handler.manual_tip_and_invoice(10, sub, *qty),
                                        inputs=[subtotal_display] + quantity_inputs, outputs=manual_tip_outputs)
                if btn_15: btn_15.click(fn=lambda sub, *qty: self.ui_handler.manual_tip_and_invoice(15, sub, *qty),
                                        inputs=[subtotal_display] + quantity_inputs, outputs=manual_tip_outputs)
                if btn_20: btn_20.click(fn=lambda sub, *qty: self.ui_handler.manual_tip_and_invoice(20, sub, *qty),
                                        inputs=[subtotal_display] + quantity_inputs, outputs=manual_tip_outputs)
                if btn_25: btn_25.click(fn=lambda sub, *qty: self.ui_handler.manual_tip_and_invoice(25, sub, *qty),
                                        inputs=[subtotal_display] + quantity_inputs, outputs=manual_tip_outputs)

                # 6. 결제 버튼('Main Interface' 탭) 클릭 시
                if payment_btn: payment_btn.click(
                    fn=self.ui_handler.process_payment,
                    inputs=[total_bill_display],
                    outputs=[payment_result]
                )
            else:
                print("Warning: Component initialization might be out of order for event handlers.")

            return interface

    def run_gradio(self):
        interface = self.create_gradio_blocks()
        interface.launch(share=True)

    def run_flask(self):
        @self.flask_app.route("/")
        def index():
            return "Hello Flask"
        self.flask_app.run(host="0.0.0.0", port=5000, debug=True)


if __name__ == "__main__":
    app = App()
    app.run_gradio()