import mysql.connector
import os
from google.genai import types
from datetime import datetime
from app.core import logger
from app.core.config import get_db_config, genai_client
from app.schemas.today_goal_schema import CheckInRequest, MorningAssessmentRequest, MorningReflectionRequest, EndDayRequest, SubmitSalesReportRequest, BossCommentRequest, CounselingRequest, FinalReviewAnalysisRequest, SubmitFinalReviewRequest, FinishCounselingRequest

# 기존 Sales_B_DB (목표 관리용)
B_DB_CONFIG = get_db_config("Sales_B_DB")

# [추가] Sales_C_DB (통계/대시보드용)
C_DB_CONFIG = get_db_config("Sales_C_DB")

def get_db_connection():
    return mysql.connector.connect(**B_DB_CONFIG)

def get_c_db_connection():
    return mysql.connector.connect(**C_DB_CONFIG)

# Sales_C_DB update common logic
# def update_sales_c_db(session_id, goals, table_name):
#     """
#     goals 리스트를 순회하며 Sales_C_DB의 table_name(am/pm)을 업데이트합니다.
#     매칭 조건: session_id, category, date(오늘)
#     """
#     conn = None
#     cursor = None
#     try:
#         conn = get_c_db_connection()
#         cursor = conn.cursor()
#         # today_date = datetime.now().strftime("%Y-%m-%d")

#         # 실제 배포시 AND date = %s 넣기
#         update_sql = f"""
#             UPDATE {table_name}
#             SET achievement = %s, achievement_rate = %s
#             WHERE session_id = %s AND category = %s
#         """

#         for g in goals:
#             # 목표치 (조정된 값이 있으면 그것을 사용)
#             # target = float(g['adjusted_target_count']) if g['adjusted_target_count'] > 0 else float(g['original_target_count'])
#             target = float(g['original_target_count'])
#             current = float(g['current_count'])
            
#             # 달성률 계산 (0 나누기 방지)
#             rate = int((current / target * 100)) if target > 0 else 0
            
#             # category가 DB에 존재하는지 확인 필요 (goals 테이블의 category 컬럼 사용)
#             category = g['category'] 

#             cursor.execute(update_sql, (current, rate, session_id, category))
        
#         conn.commit()
#         print(f"DEBUG: Updated {table_name} for session {session_id}")
        
#     except Exception as e:
#         print(f"Error updating Sales_C_DB ({table_name}): {str(e)}")
#         # C_DB 업데이트 실패가 전체 로직을 망치지 않도록 로그만 찍고 넘어감 (필요시 raise)
#     finally:
#         if cursor: cursor.close()
#         if conn: conn.close()

def update_sales_c_db(session_id, goals, table_name):
    """
    goals 리스트의 current 값으로 Sales_C_DB를 업데이트합니다.
    단, achievement_rate(달성률)은 Sales_C_DB 테이블에 이미 저장된 'target' 값을 기준으로 계산합니다.
    """
    conn = None
    cursor = None
    try:
        conn = get_c_db_connection()
        cursor = conn.cursor()
        
        # [변경 핵심] 
        # 파이썬에서 rate를 계산하지 않고, SQL 안에서 (입력받은 achievement / 테이블의 target * 100)을 수행합니다.
        # IF(target > 0, ...) 구문을 사용하여 target이 0일 때 '0으로 나누기 오류'를 방지합니다.
        # ROUND(...)를 사용하여 소수점 반올림 처리합니다 (필요시 제거 가능).
        
        update_sql = f"""
            UPDATE {table_name}
            SET achievement = %s, 
                achievement_rate = IF(target > 0, ROUND((%s / target) * 100), 0)
            WHERE session_id = %s AND category = %s
        """

        for g in goals:
            current = float(g['current_count'])
            category = g['category']
            
            # 쿼리 파라미터 순서:
            # 1. SET achievement = %s  -> current
            # 2. 계산식 내부의 %s      -> current
            # 3. WHERE session_id = %s -> session_id
            # 4. AND category = %s     -> category
            
            cursor.execute(update_sql, (current, current, session_id, category))
        
        conn.commit()
        print(f"DEBUG: Updated {table_name} using DB targets for session {session_id}")
        
    except Exception as e:
        print(f"Error updating Sales_C_DB ({table_name}): {str(e)}")
    finally:
        if cursor: cursor.close()
        if conn: conn.close()

def process_30min_checkin(db_conn, checkin_data: CheckInRequest):
    cursor = db_conn.cursor(dictionary=True)
    try:
        # 1. 목표 정보 조회
        cursor.execute("SELECT * FROM goals WHERE id = %s", (checkin_data.goal_id,))
        goal = cursor.fetchone()
        
        if not goal:
            raise ValueError("目標が見つかりません。")

        is_success = checkin_data.increment_count > 0
        
        # 2. 로그 저장
        insert_log_sql = """
            INSERT INTO check_in_logs (goal_id, increment_count, is_success, user_mood, session_type) 
            VALUES (%s, %s, %s, %s, %s)
        """

        cursor.execute(insert_log_sql, (
            checkin_data.goal_id, 
            checkin_data.increment_count, 
            is_success, 
            checkin_data.user_mood,
            checkin_data.session_type # 여기서 AM/PM 값을 넣습니다.
        ))

        # 3. 목표 카운트 업데이트
        current_db_val = float(goal['current_count']) 
        new_current_count = current_db_val + checkin_data.increment_count
        
        cursor.execute(
            "UPDATE goals SET current_count = %s WHERE id = %s",
            (new_current_count, checkin_data.goal_id)
        )
        db_conn.commit()

        # [수정된 부분] 4. 메시지에 진행 상황 포함시키기
        if goal['adjusted_target_count'] and float(goal['adjusted_target_count']) > 0:
            display_target = float(goal['adjusted_target_count'])
        else:
            display_target = float(goal['original_target_count'])
        
        # 헬퍼 함수: 정수라면(.0) 소수점을 떼고, 아니면 그대로 둠
        def fmt(num):
            return int(num) if num.is_integer() else num
        
        if is_success:
            ai_mode = "PRAISE"
            formatted_inc = fmt(checkin_data.increment_count)
            formatted_curr = fmt(new_current_count)
            formatted_target = fmt(display_target)
            
            # 소수점 표시를 위해 포맷팅 사용 (필요시 :g 등을 사용해 깔끔하게)
            progress_info = f"(累計: {formatted_curr}/{formatted_target}{goal['unit']})"
            message = f"お疲れ様です！30分で{formatted_inc}{goal['unit']}進みましたね。{progress_info} この調子でいきましょう！🔥"
        else:
            ai_mode = "COUNSELING"
            message = f"実績なしですね。ということですが、焦らずいきましょう。次の30分で挽回です！"

        return {
            "status": "success",
            "is_success": is_success,
            "ai_mode": ai_mode,
            "message": message
        }
    except Exception as e:
        db_conn.rollback()
        raise e
    finally:
        cursor.close()
        
def evaluate_morning_motivation(db_conn, request_data: MorningAssessmentRequest): 
    cursor = db_conn.cursor(dictionary=True)
    try:
        # 1. 해당 플랜의 모든 목표 가져오기 (전체 달성률 계산용)
        cursor.execute("SELECT * FROM goals WHERE plan_id = %s", (request_data.plan_id,))
        goals = cursor.fetchall()

        if not goals:
            raise ValueError("評価する目標はありません。")
        
        # personal goals
        breakdown_list = []
        total_original_target = 0.0
        total_current_count = 0.0
        
        for g in goals:
            original = float(g['original_target_count'])
            current = float(g['current_count'])
            
            total_original_target += original
            total_current_count += current
            
            # 0으로 나누기 방지
            rate = int((current / original * 100)) if original > 0 else 0
            
            breakdown_list.append({
                "title": g['title'],
                "current": current,
                "target": original,
                "rate": rate
            })

        # 2. [수정됨] 전체 목표 대비 현재 달성률(%) 계산
        if total_original_target == 0:
            score = 0
        else:
            score = int((total_current_count / total_original_target) * 100)
        
        adjusted_goals_list = []
        motivation_level = "HIGH"
        ai_summary = ""
        afternoon_action = ""

        # 3. [수정됨] 퍼센트 기반으로 멘탈 상태 판단 (예: 오전인데 40% 이상이면 HIGH로 간주)
        # 기준은 비즈니스 로직에 따라 조절 가능합니다. (여기서는 40%로 설정)
        if score >= 40:
            motivation_level = "HIGH"
            ai_summary = f"全達成率 {score}%. 素晴らしいペースです！各項目も順調に進んでいますね。"
            afternoon_action = "現在のペースが良いので、午後の目標はそのまま維持します。このまま完走しましょう！"
            
            for goal in goals:
                cursor.execute(
                    "UPDATE goals SET adjusted_target_count = %s WHERE id = %s",
                    (goal['original_target_count'], goal['id'])
                )
        else:
            motivation_level = "LOW"
            ai_summary = f"全達成率 {score}%. 目標に対して少し遅れている項目が見られます。"
            afternoon_action = "負担を減らして完走できるよう、未達成の項目を中心に目標を現実的に調整しました。"

            for goal in goals:
                original = float(goal['original_target_count'])
                current = float(goal['current_count'])
                
                if current >= original:
                    new_target = original
                else:
                    remaining = original - current
                    new_target = round(current + (remaining), 2)
                
                cursor.execute(
                    "UPDATE goals SET adjusted_target_count = %s WHERE id = %s",
                    (new_target, goal['id'])
                )
                
                if new_target != original:
                    adjusted_goals_list.append({
                        "goal_id": goal['id'],
                        "category": goal['category'],
                        "original_target": original,
                        "adjusted_target": new_target
                    })

        # 4. 결과 저장 (score에는 이제 퍼센트가 들어감)
        update_query = """
            UPDATE daily_plans 
            SET morning_motivation_score = %s, ai_feedback_summary = %s 
            WHERE id = %s
        """
        cursor.execute(update_query, (score, ai_summary, request_data.plan_id))
        db_conn.commit()
        
        # update Sales_C_DB > today_sales_am_daily 
        # plan_id로 session_id 조회
        cursor.execute("SELECT session_id FROM daily_plans WHERE id = %s", (request_data.plan_id,))
        plan_info = cursor.fetchone()
        
        if plan_info:
            update_sales_c_db(plan_info['session_id'], goals, "today_sales_am_daily")

        return {
            "motivation_level": motivation_level,
            "score": score,
            "ai_summary": ai_summary,
            "afternoon_action": afternoon_action,
            "adjusted_goals": adjusted_goals_list,
            "breakdown": breakdown_list  # [신규] 여기에 상세 내역 추가
        }

    except Exception as e:
        db_conn.rollback()
        raise e
    finally:
        cursor.close()
        

def save_morning_reflection(db_conn, request_data: MorningReflectionRequest):
    cursor = db_conn.cursor(dictionary=True)
    try:
        # 1. DB에 고민 내용 저장
        update_sql = "UPDATE daily_plans SET user_reflection = %s WHERE id = %s"
        cursor.execute(update_sql, (request_data.reflection_text, request_data.plan_id))
        db_conn.commit()

        # 2. 간단한 격려 메시지 반환 (추후 LLM 연동 가능)
        # 상담 내용이 길다면 "상세한 조언"을 해주는 로직으로 고도화 가능
        return {
            "message": "保存されました。",
            "ai_advice": "率直な振り返り、ありがとうございました。 記録していただいた悩みは、より良い成果のための土台になります。 午後も応援します！💪"
        }

    except Exception as e:
        db_conn.rollback()
        raise e
    finally:
        cursor.close()
        
        
def finish_day_and_get_report(db_conn, request_data: EndDayRequest):
    cursor = db_conn.cursor(dictionary=True)
    try:
        # 1. 목표 데이터 조회
        cursor.execute("SELECT * FROM goals WHERE plan_id = %s", (request_data.plan_id,))
        goals = cursor.fetchall()

        if not goals:
            raise ValueError("Data Not Found")

        breakdown_list = []
        total_target = 0.0
        total_current = 0.0
        
        updated_goals = []

        for g in goals:
            # Decimal -> float 변환
            # 최종 성과는 '조정된 목표(adjusted)'가 있으면 그걸 기준으로, 없으면 '원래 목표(original)' 기준
            target_val = float(g['adjusted_target_count']) if g['adjusted_target_count'] > 0 else float(g['original_target_count'])
            current_val = float(g['current_count'])
            
            total_target += target_val
            total_current += current_val

            rate = int((current_val / target_val * 100)) if target_val > 0 else 0
            
            breakdown_list.append({
                "title": g['title'],
                "current": current_val,
                "target": target_val,
                "rate": rate
            })
            
            # goals 리스트 (프론트엔드 상태 업데이트용) - Decimal 타입을 float/int로 변환
            g_copy = g.copy()
            g_copy['current_count'] = int(current_val) if current_val.is_integer() else current_val
            g_copy['original_target_count'] = int(float(g['original_target_count']))
            g_copy['adjusted_target_count'] = int(float(g['adjusted_target_count']))
            updated_goals.append(g_copy)

        # 2. 전체 달성률 계산
        final_score = int((total_current / total_target * 100)) if total_target > 0 else 0
        
        # 3. 플랜 상태 '완료'로 업데이트
        cursor.execute(
            "UPDATE daily_plans SET total_status = '完了' WHERE id = %s", 
            (request_data.plan_id,)
        )
        db_conn.commit()
        
        # update Sales_C_DB > today_sales_pm_daily 
        # plan_id로 session_id 조회
        cursor.execute("SELECT session_id FROM daily_plans WHERE id = %s", (request_data.plan_id,))
        plan_info = cursor.fetchone()
        
        if plan_info:
            update_sales_c_db(plan_info['session_id'], goals, "today_sales_pm_daily")

        # 4. 메시지 결정
        if final_score >= 100:
            msg = "本当にお疲れ様でした！目標完全達成、素晴らしい一日でしたね！🎉"
        elif final_score >= 80:
            msg = "お疲れ様でした！今日も一日よく頑張りました。ゆっくり休んでください。🍵"
        else:
            msg = "お疲れ様でした。今日は少し大変でしたか？明日はきっと良い日になります！💪"

        return {
            "final_score": final_score,
            "message": msg,
            "breakdown": breakdown_list,
            "goals": updated_goals
        }

    except Exception as e:
        db_conn.rollback()
        raise e
    finally:
        cursor.close()
                
        
def save_boss_comment(db_conn, request_data: BossCommentRequest):
    cursor = db_conn.cursor(dictionary=True)
    try:
        # 해당 세션ID와 날짜에 맞는 계획을 찾아 코멘트 업데이트
        sql = """
            UPDATE daily_plans 
            SET boss_comment = %s 
            WHERE session_id = %s AND date = %s
        """
        cursor.execute(sql, (
            request_data.boss_comment, 
            request_data.session_id, 
            request_data.date
        ))
        db_conn.commit()
        
        if cursor.rowcount == 0:
            return {"status": "error", "message": "該当日付のレポートは見つかりませんでした。"}
            
        return {"status": "success", "message": "フィードバックが保存されました。"}

    except Exception as e:
        db_conn.rollback()
        raise e
    finally:
        cursor.close()
        
        
def save_sales_report(db_conn, request_data: SubmitSalesReportRequest):
    cursor = db_conn.cursor(dictionary=True)
    try:
        # 1. 상세 내용 저장 (기존 로직 유지)
        insert_sql = """
            INSERT INTO sales_report_reflections (plan_id, goal_id, reflection_text, session_id)
            VALUES (%s, %s, %s, %s)
        """
        for item in request_data.reflections:
            if item.reflection_text and item.reflection_text.strip():
                cursor.execute(insert_sql, (
                    request_data.plan_id, 
                    item.goal_id, 
                    item.reflection_text,
                    request_data.session_id
                ))
        
        # 2. [추가] daily_plans 테이블의 제출 상태를 1(완료)로 업데이트
        update_sql = "UPDATE daily_plans SET is_report_submitted = 1 WHERE id = %s"
        cursor.execute(update_sql, (request_data.plan_id,))
        
        db_conn.commit()
        return {"message": "各項目の振り返りを保存しました。✅"}
    except Exception as e:
        db_conn.rollback()
        raise e
    finally:
        cursor.close()
        
        
# 상담 메시지 처리 및 저장 (오늘 날짜 문맥만 유지)
def process_counseling_message(db_conn, request_data: CounselingRequest):
    cursor = db_conn.cursor(dictionary=True)
    
    # 1. 오늘 날짜 구하기 (애플리케이션 기준)
    today_str = datetime.now().strftime("%Y-%m-%d")
    
    # SQL문 정의
    insert_sql = """
        INSERT INTO daily_counseling (session_id, sender, message, created_at)
        VALUES (%s, %s, %s, NOW())
    """
    
    try: # [Outer Try] DB 트랜잭션
        # 2. 유저 메시지 먼저 저장 (DB에 저장해야 history 조회 시 포함됨)
        cursor.execute(insert_sql, (request_data.session_id, "user", request_data.message))
        db_conn.commit()

        # 3. 컨텍스트 파악 (오전 성과 조회)
        plan = None
        if request_data.plan_id:
             cursor.execute("SELECT id FROM daily_plans WHERE id = %s", (request_data.plan_id,))
             plan = cursor.fetchone()
        
        if not plan:
            plan_sql = "SELECT id FROM daily_plans WHERE session_id = %s AND date = %s"
            cursor.execute(plan_sql, (request_data.session_id, today_str))
            plan = cursor.fetchone()

        context_msg = "データなし"
        if plan:
            cursor.execute("SELECT title, current_count, original_target_count, adjusted_target_count, unit FROM goals WHERE plan_id = %s", (plan['id'],))
            goals = cursor.fetchall()
            
            goal_list = []
            for g in goals:
                target = g['adjusted_target_count'] if g['adjusted_target_count'] > 0 else g['original_target_count']
                goal_list.append(f"{g['title']}: {g['current_count']}/{target}{g['unit']}")
                
            goal_status = ", ".join(goal_list)
            context_msg = f"現在の午前の成果: [{goal_status}]"

        # ---------------------------------------------------------
        # [핵심 로직] 4. 오늘 날짜의 대화 내역만 조회 (리셋 효과)
        # ---------------------------------------------------------
        history_sql = """
            SELECT sender, message 
            FROM daily_counseling 
            WHERE session_id = %s 
              AND DATE(created_at) = %s  -- [중요] 오늘 생성된 대화만 가져옴
            ORDER BY created_at ASC
        """
        cursor.execute(history_sql, (request_data.session_id, today_str))
        history_rows = cursor.fetchall()

        # 대화 내역 텍스트 변환
        chat_history_text = ""
        for row in history_rows:
            role = "User" if row['sender'] == 'user' else "AI"
            chat_history_text += f"{role}: {row['message']}\n"

        # 5. AI 답변 생성
        ai_response_text = ""
        try: # [Inner Try] AI API 호출
            if genai_client is None:
                raise ValueError("Google API Key is missing in config")

            system_prompt = f"""
            あなたは営業社員のメンタルケアとコーチングを行う専門AIです。
            
            # ユーザー情報
            - 現在の時刻: 午後1時 (午前業務終了後)
            - 本日の成果データ: {context_msg} 
            (形式: 目標項目: 現在/目標)

            # 行動指針
            1. **コンディション確認 (最優先)**:
               - ユーザーの発言から「頭痛」「腹痛」「体調が悪い」「集中できない」などの**不調**が読み取れる場合は、成果の良し悪しに関わらず、まず体を気遣ってください。
               - その上で、**「体調が優れないようですね。午後の目標数値を少し下げましょうか？」** と必ず提案してください。
               
               **[重要: 提案に対する反応への対応]**
               - **A. ユーザーが「下げてほしい」「はい」と同意した場合**:
                 「分かりました。午後の目標数値を調整します。」とだけ答えてください。これ以外の余計な慰めやアドバイスは一切不要です。
                 
               - **B. ユーザーが「いいえ」「そのままやる」と断った場合**:
                 不調をおして頑張ろうとするその姿勢を**強く称賛**し、「無理は禁物ですが、その意気込みならきっとできます！」と全力で応援してください。

            2. **共感**: (体調に問題がない場合) まずユーザーの感情に寄り添ってください。否定せず受け入れてください。
            3. **分析**: 成果データを見て、客観的な事実に基づいたアドバイスをしてください。
               - 進捗が良い場合(50%以上): 褒めて、午後の勢いをつける言葉を。
               - 進捗が悪い場合(50%未満): 責めずに、「午後は量より質でいこう」などの切り替えの提案を。
            4. **提案**: 抽象的な精神論ではなく、具体的な行動(Action)を1つ提案してください。
               (例: "まずは得意な顧客から電話してみましょう", "5分だけコーヒーブレイクを取りましょう")
            5. **口調**: 丁寧ですが、親しみやすい先輩のような口調で。(〜ですね、〜しましょう)
            6. **長さ**: 3文以内で簡潔に。長すぎると読まれません。
            """

            response = genai_client.models.generate_content(
                model="gemini-2.5-flash",
                contents=f"Contextを踏まえて、私の最新の発言「{request_data.message}」に返答してください。",
                config=types.GenerateContentConfig(
                    system_instruction=system_prompt,
                    temperature=0.4
                )
            )
            ai_response_text = response.text

            ai_response_text += "\n\nこれ以上相談したいことがなければ、下のボタンを押してください。"
            
        except Exception as ai_error:
            print(f"Gemini API Error: {ai_error}")
            ai_response_text = "通信エラーが発生しました。申し訳ありません。"

        # 6. AI 응답 저장
        cursor.execute(insert_sql, (request_data.session_id, "bot", ai_response_text))
        db_conn.commit()

        return {
            "status": "success",
            "reply": ai_response_text
        }

    except Exception as e:
        db_conn.rollback()
        raise e
    finally:
        cursor.close()
        
# AI 하루 종합 분석 생성
def generate_final_ai_review(db_conn, request_data: FinalReviewAnalysisRequest):
    cursor = db_conn.cursor(dictionary=True)
    try:
        # 1. 목표 및 달성률 조회
        cursor.execute("SELECT * FROM goals WHERE plan_id = %s", (request_data.plan_id,))
        goals = cursor.fetchall()
        
        # 2. 유저가 방금 작성한 항목별 회고 조회
        # sales_report_reflections 테이블과 goals 테이블 조인
        sql = """
            SELECT g.title, g.original_target_count, g.current_count, g.unit, r.reflection_text
            FROM goals g
            LEFT JOIN sales_report_reflections r ON g.id = r.goal_id
            WHERE g.plan_id = %s
        """
        cursor.execute(sql, (request_data.plan_id,))
        details = cursor.fetchall()
        
        # 오늘 오전 상담 내용 조회 (daily_counseling)
        counsel_sql = """
            SELECT message, sender 
            FROM daily_counseling 
            WHERE session_id = %s 
              AND DATE(created_at) = CURDATE()
            ORDER BY created_at ASC
        """
        cursor.execute(counsel_sql, (request_data.session_id,)) # request에 session_id 필요
        counsel_logs = cursor.fetchall()
        
        # 상담 내용을 텍스트로 요약
        counseling_context = ""
        if counsel_logs:
            counseling_context = "\n".join([f"- {log['sender']}: {log['message']}" for log in counsel_logs])
        else:
            counseling_context = "特になし (Consultation skipped)"
        
        # 3. 프롬프트 데이터 구성
        report_summary = ""
        total_target = 0
        total_current = 0
        
        for d in details:
            target = float(d['original_target_count'])
            current = float(d['current_count'])
            total_target += target
            total_current += current
            
            report_summary += f"- {d['title']}: {current}/{target}{d['unit']} (Reflection: {d['reflection_text'] or 'なし'})\n"
            
        total_rate = int(total_current / total_target * 100) if total_target > 0 else 0

        # 4. Gemini 호출
        if genai_client is None:
            raise ValueError("Gemini Client Not Configured")

        system_prompt = f"""
        あなたは営業チームの優秀なマネージャーAIです。
        部下が提出した「本日の営業日報」と、午前中に交わした「相談内容」を総合的に分析し、一日の総括コメントを作成してください。
        
        # 📊 データ
        1. 全体達成率: {total_rate}%
        2. 午前中の相談内容 (Context):
        {counseling_context}
        
        3. 詳細レポート (振り返り):
        {report_summary}
        
        # 📝 指示
        1. **ストーリーの接続**: もし午前中に悩み(相談)があったなら、その悩みが午後どうなったか（克服したか、まだ続いているか）に触れてください。
        2. **労いと称賛**: 結果だけでなく、過程やメンタルの変化を褒めてください。
        3. **分析**: ユーザーが書いた「振り返り」と「実績」を照らし合わせてフィードバックしてください。
        4. **次へのアクション**: 明日に向けた簡潔なアドバイスを1つ。
        5. **トーン**: 温かく、信頼できるパートナーとして。
        """

        response = genai_client.models.generate_content(
            model="gemini-2.5-flash", # 혹은 1.5-flash
            contents="本日の日報に対するフィードバックをお願いします。",
            config=types.GenerateContentConfig(
                system_instruction=system_prompt,
                temperature=0.7
            )
        )
        
        ai_comment = response.text
        
        return {
            "status": "success",
            "ai_comment": ai_comment,
            "total_rate": total_rate
        }

    except Exception as e:
        print(f"Error generating review: {e}")
        # 에러 시 기본 멘트 리턴
        return {
            "status": "error",
            "ai_comment": "AI分析中にエラーが発生しました。しかし、今日の一日は確実にあなたの力になっています。お疲れ様でした。",
            "total_rate": 0
        }
    finally:
        cursor.close()

# 최종 리뷰 저장
def save_final_review(db_conn, request_data: SubmitFinalReviewRequest):
    cursor = db_conn.cursor(dictionary=True)
    try:
        sql = """
            UPDATE daily_plans 
            SET final_user_comment = %s, final_ai_comment = %s
            WHERE id = %s
        """
        cursor.execute(sql, (request_data.final_user_comment, request_data.final_ai_comment, request_data.plan_id))
        db_conn.commit()
        
        return {"message": "日報が完全に保存されました。本日も本当にお疲れ様でした！"}
    except Exception as e:
        db_conn.rollback()
        raise e
    finally:
        cursor.close()

# [수정 필요] 상사가 보는 리포트(get_boss_daily_reports)에도 새 컬럼 추가
def get_boss_daily_reports(db_conn, session_id: str):
    cursor = db_conn.cursor(dictionary=True)
    try:
        # final_ai_comment, final_user_comment 추가 조회
        plan_sql = """
            SELECT id, date, total_status, boss_comment, final_ai_comment, final_user_comment, morning_motivation
            FROM daily_plans 
            WHERE session_id = %s 
            ORDER BY date DESC LIMIT 30
        """
        cursor.execute(plan_sql, (session_id,))
        plans = cursor.fetchall()
        
        results = []
        for p in plans:
            # 2. 상세 목표 및 회고 조회
            detail_sql = """
                SELECT 
                    g.title, g.original_target_count, g.current_count, g.unit,
                    r.reflection_text
                FROM goals g
                LEFT JOIN sales_report_reflections r ON g.id = r.goal_id
                WHERE g.plan_id = %s
            """
            
            cursor.execute(detail_sql, (p['id'],))
            details = cursor.fetchall()
            
            formatted_details = []
            for d in details:
                orig = float(d['original_target_count'])
                curr = float(d['current_count'])
                rate = int(curr / orig * 100) if orig > 0 else 0
                
                formatted_details.append({
                    "title": d['title'],
                    "target": int(orig) if orig.is_integer() else orig,
                    "current": int(curr) if curr.is_integer() else curr,
                    "unit": d['unit'],
                    "rate": rate,
                    "reflection": d['reflection_text'] or ""
                })
                
            # 3. 오전 상담 로그 조회
            counsel_sql = """
                SELECT sender, message, DATE_FORMAT(created_at, '%H:%i') as time
                FROM daily_counseling 
                WHERE session_id = %s AND DATE(created_at) = %s
                ORDER BY created_at ASC
            """
            cursor.execute(counsel_sql, (session_id, p['date']))
            counsel_logs = cursor.fetchall()
            
            results.append({
                "plan_id": p['id'],
                "date": str(p['date']),
                "status": p['total_status'],
                "boss_comment": p['boss_comment'],
                "final_ai_comment": p['final_ai_comment'],
                "final_user_comment": p['final_user_comment'],
                "mindset": p['morning_motivation'],
                "details": formatted_details,
                "counseling_logs": counsel_logs
            })
            
        return {"data": results}
    except Exception as e:
        raise e
    finally:
        cursor.close()
        
        
def summarize_morning_counseling(db_conn, request_data: FinishCounselingRequest):
    cursor = db_conn.cursor(dictionary=True)
    try:
        # 1. 오늘 나눈 상담 로그 조회
        sql = """
            SELECT sender, message 
            FROM daily_counseling 
            WHERE session_id = %s AND DATE(created_at) = CURDATE()
            ORDER BY created_at ASC
        """
        cursor.execute(sql, (request_data.session_id,))
        logs = cursor.fetchall()
        
        if not logs:
            return {"status": "skipped", "message": "No counseling logs found."}

        # 2. 대화 내용 텍스트화
        context_text = "\n".join([f"{l['sender']}: {l['message']}" for l in logs])
        
        # 3. Gemini에게 요약 요청
        if genai_client is None:
             raise ValueError("Google API Key is missing")

        system_prompt = """
        あなたは営業マネージャーのアシスタントAIです。
        午前業務終了後の「部下との相談チャットログ」を分析し、
        部下の「現在のモチベーション状態」や「抱えている悩み」を
        日本語で 1〜2文の簡潔な要約文 にまとめてください。
        
        この要約はデータベースの 'morning_motivation' カラムに保存され、
        上司が部下の状態を把握するために使われます。
        
        出力例:
        - 電話が繋がらず落ち込んでいたが、午後はアプローチを変えて頑張るとのこと。
        - 目標を上回るペースで進んでおり、意欲は非常に高い。
        - 疲れが見えるため、午後のこまめな休憩を提案した。
        - コンディションが悪そうなので、午後の目標数を減らすことを提案した。
        """
        
        response = genai_client.models.generate_content(
            model="gemini-2.5-flash", 
            contents=f"Chat Logs:\n{context_text}",
            config=types.GenerateContentConfig(
                system_instruction=system_prompt,
                temperature=0.5
            )
        )
        
        summary = response.text

        # 4. daily_plans 테이블의 morning_motivation 컬럼 업데이트
        update_sql = "UPDATE daily_plans SET morning_motivation = %s WHERE id = %s"
        cursor.execute(update_sql, (summary, request_data.plan_id))
        db_conn.commit()
        
        return {"status": "success", "summary": summary}

    except Exception as e:
        db_conn.rollback()
        # 에러가 나도 프론트엔드 흐름은 끊기지 않게 로그만 찍고 넘어가는 게 좋을 수도 있음
        print(f"Error summarizing counseling: {e}")
        raise e
    finally:
        cursor.close()
        
        
def get_team_goal_rates(session_id: str):
    """
    Sales_C_DB의 T_daily 테이블에서 팀의 목표 달성률을 조회하고,
    숫자로 된 카테고리 ID를 실제 항목명으로 변환하여 반환합니다.
    """
    conn = None
    cursor = None
    
    # DB의 숫자(ID)를 실제 항목명으로 변환하기 위한 매핑 딕셔너리
    CATEGORY_MAP = {
        "1": "リストアップ",
        "2": "架電数",
        "3": "繋がるための行動",
        "4": "アポ",
        "5": "訪問",
        "6": "見積",
        "7": "見積額",
        "8": "受注",
        "9": "受注額"
    }

    try:
        conn = get_c_db_connection()
        cursor = conn.cursor(dictionary=True)
        
        sql = """
            SELECT category, achievement_rate 
            FROM T_daily 
            WHERE session_id = %s
        """
        cursor.execute(sql, (session_id,))
        rates = cursor.fetchall()
        
        result = {}
        
        if rates:
            for r in rates:
                # DB에 저장된 값을 문자열로 변환 (예: 숫자 1 -> 문자열 "1")
                cat_key = str(r['category'])
                
                # 매핑 딕셔너리에서 일본어 이름을 찾음. (만약 없으면 원래 숫자 그대로 반환)
                cat_name = CATEGORY_MAP.get(cat_key, cat_key)
                
                result[cat_name] = r['achievement_rate']
            
            return result
        
        return {
            "リストアップ": 75,
            "架電数": 75,
            "繋がるための行動": 75
        }

    except Exception as e:
        print(f"Error fetching team goal rates from T_daily: {e}")
        return {
            "各項目": "設定された基準"
        }
    finally:
        if cursor: cursor.close()
        if conn: conn.close()