app.py

import gradio as gr
import re
import datetime
import calendar
import requests
import json
from datetime import datetime

# ================== 컨셉 분석 모듈 ==================
class ConceptAnalyzer:
    def __init__(self):
        self.monthly_data = {
            "1월": {
                "special_days": ["미니멀 챌린지", "새해 리셋", "건강한 습관 만들기", "갓생 챌린지", "21일 습관 만들기"],
                "trends": ["미니멀", "자기계발", "플래너", "정리정돈", "갓생살기", "건강한 루틴", "새해 결심", "미라클 모닝", "홈트", "독서"],
                "colors": ["#FF6B6B", "#4ECDC4", "#45B7D1"],
                "mood": "희망적이고 새로운 시작",
                "female_appeal": ["미니멀", "자기계발", "셀프케어", "건강한 습관", "갓생"]
            },
            "2월": {
                "special_days": ["갈렌타인데이", "셀프러브", "사랑의 달", "자기사랑 챌린지", "따뜻한 마음 나누기"],
                "trends": ["셀프러브", "갈렌타인", "로맨스", "따뜻한 감성", "자기사랑", "친구사랑", "감성 카페", "겨울 데이트", "따뜻한 차", "아늑한 집콕"],
                "colors": ["#FF69B4", "#FFB6C1", "#DC143C"],
                "mood": "로맨틱하고 감성적",
                "female_appeal": ["셀프러브", "우정", "로맨스", "자기사랑", "갈렌타인"]
            },
            "3월": {
                "special_days": ["여성의 날", "봄의 시작", "새학기", "벚꽃 예보", "봄맞이 준비"],
                "trends": ["봄맞이", "벚꽃 시즌", "봄 패션", "새출발", "봄 정리", "꽃구경", "봄 여행", "라이프스타일 변화", "새 시작", "봄 데이트"],
                "colors": ["#FFB6C1", "#98FB98", "#87CEEB"],
                "mood": "설렘가득하고 활기찬",
                "female_appeal": ["봄 패션", "꽃구경", "새출발", "라이프스타일", "봄맞이"]
            },
            "4월": {
                "special_days": ["벚꽃 시즌", "봄나들이", "피크닉", "야외 활동", "봄 여행"],
                "trends": ["벚꽃축제", "봄피크닉", "아웃도어", "꽃놀이", "야외 운동", "캠핑", "등산", "자전거", "봄 축제", "꽃구경"],
                "colors": ["#98FB98", "#F0E68C", "#DDA0DD"],
                "mood": "생기발랄하고 즐거운",
                "female_appeal": ["벚꽃놀이", "피크닉", "봄여행", "야외활동", "꽃구경"]
            },
            "5월": {
                "special_days": ["로즈데이", "감사의 달", "어버이날", "가정의 달", "스승의 날"],
                "trends": ["감사", "나들이", "로즈데이", "봄여행", "가족사랑", "효도", "감사표현", "선물", "힐링", "여행"],
                "colors": ["#32CD32", "#FFB6C1", "#87CEEB"],
                "mood": "따뜻하고 감사한",
                "female_appeal": ["로즈데이", "감사표현", "힐링", "가족사랑", "선물"]
            },
            "6월": {
                "special_days": ["키스데이", "여름 준비", "쿨링", "결혼 시즌", "초여름"],
                "trends": ["여름준비", "쿨링", "바캉스준비", "여름패션", "다이어트", "여름 화장품", "시원한 음료", "여름 레시피", "휴가 계획", "웨딩"],
                "colors": ["#00CED1", "#FFD700", "#FF6347"],
                "mood": "시원하고 활동적인",
                "female_appeal": ["여름준비", "쿨링케어", "바캉스", "다이어트", "여름패션"]
            },
            "7월": {
                "special_days": ["실버데이", "여름휴가", "바캉스", "휴가철", "여름 축제"],
                "trends": ["여름휴가", "바캉스", "휴가패션", "여행", "해변", "수영장", "페스티벌", "여름 액티비티", "서핑", "다이빙"],
                "colors": ["#00BFFF", "#FFD700", "#FF6347"],
                "mood": "역동적이고 자유로운",
                "female_appeal": ["바캉스", "여행", "휴가패션", "여름축제", "해변"]
            },
            "8월": {
                "special_days": ["여름 마무리", "휴가", "여름 추억", "페스티벌", "야외 파티"],
                "trends": ["여름휴가", "바다여행", "축제", "여름추억", "페스티벌", "야외 파티", "캠핑", "글램핑", "워터파크", "여름 간식"],
                "colors": ["#00BFFF", "#FF6347", "#FFD700"],
                "mood": "열정적이고 추억가득한",
                "female_appeal": ["여름추억", "힐링", "여행", "페스티벌", "야외활동"]
            },
            "9월": {
                "special_days": ["포토데이", "뮤직데이", "가을시작", "독서의 계절", "문화생활"],
                "trends": ["가을패션", "독서", "문화생활", "감성", "카페", "전시회", "공연", "예술", "취미", "자기계발"],
                "colors": ["#FF8C00", "#DC143C", "#B8860B"],
                "mood": "감성적이고 성숙한",
                "female_appeal": ["가을패션", "카페", "독서", "문화생활", "취미"]
            },
            "10월": {
                "special_days": ["와인데이", "커피데이", "독서의 달", "할로윈", "가을 여행"],
                "trends": ["가을단풍", "독서", "카페문화", "와인", "할로윈", "단풍구경", "등산", "가을 여행", "코스모스", "감성 사진"],
                "colors": ["#FF8C00", "#DC143C", "#B8860B"],
                "mood": "감성적이고 여유로운",
                "female_appeal": ["단풍구경", "카페", "와인", "가을여행", "할로윈"]
            },
            "11월": {
                "special_days": ["무비데이", "오렌지데이", "연말준비", "빼빼로데이", "추수감사"],
                "trends": ["빼빼로데이", "연말준비", "겨울패션", "따뜻함", "영화", "독서", "겨울 준비", "연말 모임", "따뜻한 차", "홈파티"],
                "colors": ["#8B4513", "#A0522D", "#CD853F"],
                "mood": "포근하고 준비하는",
                "female_appeal": ["빼빼로데이", "겨울패션", "연말모임", "영화감상", "홈파티"]
            },
            "12월": {
                "special_days": ["허그데이", "연말파티", "송년", "크리스마스", "연말 결산"],
                "trends": ["크리스마스", "연말파티", "선물", "송년회", "연말 결산", "한 해 마무리", "감사", "새해 계획", "겨울 데이트", "홈파티"],
                "colors": ["#DC143C", "#228B22", "#FFD700"],
                "mood": "축제같고 따뜻한",
                "female_appeal": ["크리스마스", "연말모임", "선물", "한해마무리", "감사"]
            }
        }
    
    def extract_month_from_period(self, period_text):
        if not period_text or period_text.strip() == "":
            return None
        
        date_patterns = [
            r'(\d{4})\.(\d{1,2})\.(\d{1,2})',
            r'(\d{1,2})\.(\d{1,2})',
            r'(\d{1,2})월',
        ]
        
        for pattern in date_patterns:
            matches = re.findall(pattern, period_text)
            if matches:
                if len(matches[0]) == 3:
                    month = int(matches[0][1])
                elif len(matches[0]) == 2:
                    month = int(matches[0][0])
                else:
                    month = int(matches[0])
                
                if 1 <= month <= 12:
                    return f"{month}월"
        
        return None

    def analyze_concepts(self, month):
        data = self.monthly_data.get(month, {})
        
        concepts = []
        
        # 10개의 다양한 컨셉 생성
        special_days = data.get("special_days", [])
        trends = data.get("trends", [])
        female_appeal = data.get("female_appeal", [])
        
        for i in range(min(10, len(special_days) + len(trends))):
            if i < len(special_days):
                concept_name = f"{special_days[i]} 이벤트"
                theme = f"{special_days[i]}를 테마로 한 참여형 이벤트"
                keywords = [special_days[i]] + female_appeal[:2]
                score = 8.8 - (i * 0.1)
                is_recommended = i < 3
            else:
                trend_idx = i - len(special_days)
                if trend_idx < len(trends):
                    trend = trends[trend_idx]
                    concept_name = f"{trend} 챌린지"
                    theme = f"{trend} 참여형 챌린지 이벤트"
                    keywords = [trend] + trends[trend_idx+1:trend_idx+3]
                    score = 8.0 - (trend_idx * 0.1)
                    is_recommended = trend_idx < 2
                else:
                    break
            
            concepts.append({
                "name": concept_name,
                "theme": theme,
                "score": round(score, 1),
                "reason": f"20-40대 여성에게 인기 높은 {concept_name.split()[0]} 테마",
                "target": "20-40대 여성",
                "colors": data.get("colors", ["#FF69B4"]),
                "keywords": keywords,
                "is_recommended": is_recommended
            })
        
        concepts.sort(key=lambda x: (x.get("is_recommended", False), x["score"]), reverse=True)
        
        recommended_concept = next((c for c in concepts if c.get("is_recommended", False)), concepts[0])
        
        result = f"# 🎯 {month} 20-40대 여성 맞춤 컨셉 분석\n\n"
        result += f"## 🏆 이달의 추천 컨셉: {recommended_concept['name']}\n"
        result += f"**⭐ 추천 이유:** {recommended_concept['reason']}\n"
        result += f"**📊 예상 참여도:** {recommended_concept['score']}/10점\n\n"
        result += "---\n\n"
        
        concept_names = []
        
        for i, concept in enumerate(concepts, 1):
            is_recommended_mark = " 🏆 **추천**" if concept.get("is_recommended", False) else ""
            result += f"## {i}. {concept['name']}{is_recommended_mark}\n"
            result += f"**🏷️ 테마:** {concept['theme']}\n"
            result += f"**⭐ 참여도 점수:** {concept['score']}/10점\n"
            result += f"**💡 선정 이유:** {concept['reason']}\n"
            result += f"**🎯 주요 타겟:** {concept['target']}\n"
            result += f"**🔑 핵심 키워드:** {', '.join(concept['keywords'])}\n"
            result += f"**🎨 추천 색상:** {', '.join(concept['colors'])}\n\n"
            result += "---\n\n"
            
            concept_names.append(concept['name'])
        
        return result, concept_names

    def generate_trendy_copy(self, concept_name, month):
        """트렌디한 카피라이팅 생성"""
        
        trendy_copies = {
            "미니멀": {
                "sub1": "🌟 '나는 정리를 못하는 여자'는 이제 그만!",
                "main": "미니멀은 '미'니로 '말'하는 거야, 작게 말해도 큰 변화! ✨",
                "sub2": "올해는 진짜 '갓생'을 살아보자구요! 💪",
                "hashtags": ["#갓생살기", "#미니멀", "#정리의신", "#새해정리"]
            },
            "셀프케어": {
                "sub1": "💕 '나 자신과 연애 중'이라고 말할 수 있나요?",
                "main": "셀프케어는 '셀프'로 '케어'하는 거 맞아! 💖",
                "sub2": "오늘부터 내가 내 최고의 친구가 되는 거야 ✨",
                "hashtags": ["#셀프케어", "#나를위한시간", "#힐링", "#자기사랑"]
            },
            "갓생": {
                "sub1": "✨ 매일 똑같은 하루가 지겨우신가요?",
                "main": "갓생은 '갓'처럼 살아보자는 거야! 너도 할 수 있어 🔥",
                "sub2": "작은 변화가 큰 행복을 만들어요 💫",
                "hashtags": ["#갓생살기", "#미라클모닝", "#자기계발", "#루틴만들기"]
            },
            "챌린지": {
                "sub1": "🎯 혼자서는 어려워도 함께라면 가능해!",
                "main": "챌린지는 '챌'만 해봐도 성공이야! 도전해볼까? 🚀",
                "sub2": "우리 함께 새로운 나를 만나러 가요 ✨",
                "hashtags": ["#챌린지", "#함께해요", "#새로운나", "#도전"]
            },
            "벚꽃": {
                "sub1": "🌸 봄이 왔어요! 설레는 마음 준비되셨나요?",
                "main": "벚꽃은 '벚'보다 '꽃'이 중요해! 꽃처럼 예쁘게 피어나요 🌺",
                "sub2": "짧지만 아름다운 순간을 함께 만들어요 💕",
                "hashtags": ["#벚꽃놀이", "#봄나들이", "#꽃구경", "#봄감성"]
            },
            "바캉스": {
                "sub1": "🏖️ 더위는 싫어도 여름은 좋아하는 사람?",
                "main": "바캉스는 '바'쁜 일상에서 '캉'스럽게 쉬는 거야! 🌊",
                "sub2": "올여름 가장 핫한 추억을 만들어봐요 🔥",
                "hashtags": ["#바캉스", "#여름휴가", "#힐링여행", "#여름추억"]
            },
            "카페": {
                "sub1": "☕ 오늘도 카페인에 의존하며 살고 계신가요?",
                "main": "카페는 '카'페인보다 '페'이스북 같은 소통공간! 📸",
                "sub2": "따뜻한 커피 한 잔으로 시작하는 특별한 하루 ✨",
                "hashtags": ["#카페투어", "#커피타임", "#감성카페", "#카페추천"]
            },
            "크리스마스": {
                "sub1": "🎄 올해 크리스마스는 뭔가 특별하게 보내고 싶다면?",
                "main": "크리스마스는 '크'게 '리'액션하며 '스'페셜하게! 🎅",
                "sub2": "따뜻한 마음이 가득한 연말을 함께 만들어요 💝",
                "hashtags": ["#크리스마스", "#연말파티", "#선물", "#따뜻한연말"]
            }
        }
        
        # 기본 카피
        default_copy = {
            "sub1": "✨ 이런 특별한 순간을 놓칠 수 없죠!",
            "main": "지금 이 순간이 바로 '찐'이야! 💫",
            "sub2": "함께라면 뭐든 '레전드'가 될 수 있어요 🎉",
            "hashtags": ["#찐이야", "#레전드순간", "#함께해요", "#특별한시간"]
        }
        
        # 컨셉명에서 키워드 찾기
        for keyword, copy_data in trendy_copies.items():
            if keyword in concept_name:
                return copy_data
        
        return default_copy

# ================== 이벤트 관리 모듈 ==================
class EventManager:
    def __init__(self):
        self.reward_types = [
            "네이버페이 금액권",
            "배달의민족 상품권", 
            "스타벅스 기프트카드",
            "CGV 영화관람권",
            "올리브영 상품권"
        ]

    def calculate_event_duration(self, start_date, end_date):
        try:
            start = datetime.strptime(start_date, "%Y-%m-%d")
            end = datetime.strptime(end_date, "%Y-%m-%d")
            duration = (end - start).days + 1
            month = start.month
            
            start_weekday = start.strftime("(%a)")
            end_weekday = end.strftime("(%a)")
            
            return duration, month, start_weekday, end_weekday, start, end
        except:
            return 0, 0, "", "", None, None

    def generate_detailed_comment_event(self, start_date, end_date, concept, reward_structure, kakao_id, phone_number):
        if not concept:
            return "먼저 이벤트 컨셉을 입력해주세요."
        
        duration_info, month, start_weekday, end_weekday, start_dt, end_dt = self.calculate_event_duration(start_date, end_date)
        
        if duration_info == 0:
            return "날짜 형식을 확인해주세요."
        
        formatted_start = f"{start_dt.year}년 {start_dt.month}월 {start_dt.day}일 {start_weekday} 00:00"
        formatted_end = f"{end_dt.year}년 {end_dt.month}월 {end_dt.day}일 {end_weekday} 23:59"
        
        template = f"""댓글 남기면 1시간마다 선물이!
🎉 {concept} 이벤트

{formatted_start} - {formatted_end} ({duration_info}일간)

========================
EVENT
<커뮤니티>에 작성된 글에 유익하고 착한 댓글을 남기면
1시간마다 1명씩! 하루 24명에게 선물을드려요!

{formatted_start} - {formatted_end} ({duration_info}일간)

=====================
STEP 1
회사명 <커뮤니티>에 작성된 글에
유익하고 착한 댓글 작성
* 이쁘고 좋은 말 많이 해주는 회원님들이 되길 부탁드려요

STEP 2
댓글 작성 후 선물 당첨 팝업이 나타나면
화면캡쳐 또는 사진촬영하기!
*당첨팝업은 이벤트 기간동안 1시간마다 1명씩!
하루 24명에게 나타나요!

STEP 3
당첨팝업 캡쳐 & 촬영했으면
카카오톡 또는 고객센터로 연락하기!

=================
당첨혜택
{reward_structure}

========================
이벤트 대상
일반 여성회원이라면 누구나!
(*회원, 비회원 모두 참여가능 / 기업회원제외)

========================
수령방법
댓글 작성 후 랜덤하게뜨는 이미지를 캡처 or 사진 촬영하기!
꼭 캡처후 팝업을 닫아주세요!

1.상단 당첨 날짜와 시간이 함께 나오도록 
화면캡쳐 또는 사진촬영

2.카카오톡 ({kakao_id}) 로 캡쳐 사진 보내기

3.카카오톡으로 연락처를 남기거나
고객센터 운영시간에 맞춰 전화하기

4. 고객센터와 여성회원 확인 통화 후
선물 받기!

=========================
꼭 확인하세요!
※본이벤트는 회사명 일반 여성회원만 참여가능합니다. (비회원도 가능)
※ pc에서 캡처가 어려운 경우, 카메라로 촬영하여 연락 주셔도 됩니다.
※이벤트 팝업 상품 이미지와 상단 당첨 날짜&시간을 함께
화면 캡처 또는 사진 촬영해야 수령 가능합니다.
※ 화면 캡처 전에 팝업을 닫을 시, 상품 지급이 어려우니 반드시 캡처 또는
촬영 후 팝업을 닫아주세요!
※당첨 시 여성확인절차가 있음으로 고객센터로 연락 주시기 바랍니다. (통화로 여성확인)
※ 고객센터와 여성 확인 통화 후 상품 수령가능합니다.
※ 상품은 1인 1일 최대 1회까지 수령이 가능합니다. 같은 날 재당첨되어도
지급되지 않습니다. 단, 날짜가 다를 시 중복 수령 가능합니다.
※ 상품 수령 가능 기간은 당첨 일로부터 영업일 기준 다음 날까지 가능합니다.
ex) 주말 당첨시, 고객센터 영업일(월) 업무 종료시간 19:00시까지 수령가능

===========================
{phone_number}
※ 대표번호는 문자수신이 불가합니다
고객센터 운영시간
(평일 09:30~19:00 / 점심 12:00~13:30)
※ 주말 및 공휴일은 운영하지 않습니다.
카카오톡 ID: {kakao_id}
"""
        
        return template

    def generate_design_advice(self, concept):
        advice = f"""🎨 디자인 조언 ({concept} 테마)

🎯 컬러 팔레트
- 20-40대 여성에게 어필하는 따뜻하고 친근한 색상
- 메인 컬러: 브랜드 컬러와 조화
- 서브 컬러: 가독성을 높이는 대비 색상

📐 레이아웃 구조
1. **메인 제목**: 임팩트 있는 큰 폰트 + 이모티콘
2. **날짜 정보**: 박스로 구분하여 명확하게 표시
3. **EVENT 섹션**: 굵은 구분선으로 강조
4. **STEP 가이드**: 숫자와 함께 단계별 명확한 구분
5. **당첨혜택**: 상품 이미지와 함께 시각적으로 강조
6. **주의사항**: 읽기 쉽게 ※ 기호로 구분

👀 가독성 향상 포인트
- 구분선(=====) 활용으로 섹션 명확히 분리
- 중요 정보는 박스 처리 또는 배경색 변경
- 단계별 가이드는 아이콘과 함께 시각화
- 모바일에서도 스크롤하며 읽기 편하게 구성

🔥 핵심 강조 요소
- "1시간마다 1명씩" - 긴급성 강조
- "하루 24명" - 기회의 많음 어필
- 상품 이미지 - 실제 혜택 시각화
- 참여 방법 - 간단함 강조"""

        return advice

# ================== API 연동 모듈 ==================
class APIIntegrations:
    def __init__(self):
        self.api_status = {}
        
    def test_instagram_api(self, access_token):
        try:
            if not access_token:
                return {"status": "error", "message": "Access Token이 필요합니다"}
            
            url = f"https://graph.instagram.com/me?fields=id,username&access_token={access_token}"
            response = requests.get(url, timeout=10)
            
            if response.status_code == 200:
                data = response.json()
                return {
                    "status": "success", 
                    "message": f"Instagram 연결 성공 - @{data.get('username', 'unknown')}"
                }
            else:
                return {"status": "error", "message": "Instagram API 인증 실패"}
                
        except Exception as e:
            return {"status": "error", "message": f"Instagram 연결 오류: {str(e)}"}
    
    def test_analytics_api(self, tracking_id):
        try:
            if not tracking_id:
                return {"status": "error", "message": "Tracking ID가 필요합니다"}
            
            if tracking_id.startswith("G-"):
                return {"status": "success", "message": f"Google Analytics 설정 확인됨 - {tracking_id}"}
            else:
                return {"status": "error", "message": "올바른 GA4 Tracking ID 형식이 아닙니다 (G-XXXXXXXXX)"}
                
        except Exception as e:
            return {"status": "error", "message": f"Analytics 연결 오류: {str(e)}"}
    
    def test_openai_api(self, api_key):
        try:
            if not api_key:
                return {"status": "error", "message": "API Key가 필요합니다"}
            
            headers = {
                "Authorization": f"Bearer {api_key}",
                "Content-Type": "application/json"
            }
            
            url = "https://api.openai.com/v1/models"
            response = requests.get(url, headers=headers, timeout=10)
            
            if response.status_code == 200:
                return {"status": "success", "message": "OpenAI API 연결 성공"}
            else:
                return {"status": "error", "message": "OpenAI API 인증 실패"}
                
        except Exception as e:
            return {"status": "error", "message": f"OpenAI API 연결 오류: {str(e)}"}
    
    def test_all_connections(self, enable_instagram, instagram_token, enable_analytics, ga_tracking_id, enable_chatgpt, openai_api_key):
        results = []
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        results.append(f"🔍 API 연결 테스트 결과 - {timestamp}\n" + "="*50 + "\n")
        
        if enable_instagram:
            instagram_result = self.test_instagram_api(instagram_token)
            status_icon = "✅" if instagram_result["status"] == "success" else "❌"
            results.append(f"{status_icon} Instagram: {instagram_result['message']}")
        
        if enable_analytics:
            analytics_result = self.test_analytics_api(ga_tracking_id)
            status_icon = "✅" if analytics_result["status"] == "success" else "❌"
            results.append(f"{status_icon} Analytics: {analytics_result['message']}")
        
        if enable_chatgpt:
            openai_result = self.test_openai_api(openai_api_key)
            status_icon = "✅" if openai_result["status"] == "success" else "❌"
            results.append(f"{status_icon} OpenAI: {openai_result['message']}")
        
        if len(results) == 1:
            results.append("⚠️ 설정된 API가 없습니다. API를 활성화해주세요.")
        
        return "\n".join(results)
    
    def generate_enhanced_concept_with_chatgpt(self, month, api_key):
        try:
            headers = {
                "Authorization": f"Bearer {api_key}",
                "Content-Type": "application/json"
            }
            
            prompt = f"""
            {month}에 진행할 20-40대 여성 대상 이벤트의 창의적인 컨셉을 3개 제안해주세요.
            각 컨셉은 다음을 포함해야 합니다:
            - 컨셉명
            - 핵심 아이디어  
            - 예상 참여도 (1-10점)
            - 타겟층 특징
            - 트렌디한 해시태그 3개
            - 실행 방법
            
            현재 유행하는 소셜미디어 트렌드와 MZ세대 관심사를 반영해주세요.
            2024년 하반기 트렌드를 고려하여 답변해주세요.
            """
            
            data = {
                "model": "gpt-3.5-turbo",
                "messages": [
                    {"role": "user", "content": prompt}
                ],
                "max_tokens": 1500,
                "temperature": 0.8
            }
            
            response = requests.post(
                "https://api.openai.com/v1/chat/completions",
                headers=headers,
                json=data,
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                enhanced_content = result["choices"][0]["message"]["content"]
                
                return f"""🤖 AI로 강화된 {month} 이벤트 컨셉

{enhanced_content}

---
💡 이 컨셉들을 기본 컨셉과 결합하여 더욱 창의적인 이벤트를 만들어보세요!
📊 각 컨셉의 예상 참여도를 참고하여 최적의 컨셉을 선택하실 수 있습니다."""
            else:
                return "ChatGPT API 요청 실패. API Key와 네트워크 연결을 확인해주세요."
                
        except Exception as e:
            return f"ChatGPT API 오류: {str(e)}"

# ================== 메인 애플리케이션 ==================
def create_interface():
    concept_analyzer = ConceptAnalyzer()
    event_manager = EventManager()
    api_integrations = APIIntegrations()
    
    with gr.Blocks(title="통합 이벤트 관리 시스템", theme=gr.themes.Soft()) as demo:
        
        gr.Markdown("# 🎉 통합 이벤트 관리 시스템")
        gr.Markdown("### 컨셉 분석 + 이벤트 생성 + API 연동을 한 번에!")
        
        with gr.Tabs():
            with gr.Tab("🎯 컨셉 분석"):
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("## 📅 이벤트 기간 설정")
                        concept_event_period = gr.Textbox(
                            label="이벤트 기간",
                            placeholder="예: 2025.8.1 ~ 2025.8.10",
                            info="기간을 입력하면 자동으로 월별 컨셉 분석"
                        )
                        
                        concept_month = gr.Dropdown(
                            choices=[f"{i}월" for i in range(1, 13)],
                            label="월 선택",
                            value="8월"
                        )
                        
                        analyze_concept_btn = gr.Button("🔍 컨셉 분석하기", variant="primary")
                        
                        selected_concept = gr.Dropdown(
                            label="분석된 컨셉 선택",
                            visible=False
                        )
                        
                        custom_concept_input = gr.Textbox(
                            label="직접 컨셉 입력",
                            placeholder="원하는 컨셉을 직접 입력하세요",
                            visible=False,
                            info="분석된 컨셉 외에 다른 아이디어가 있다면 입력해주세요"
                        )
                        
                    with gr.Column():
                        concept_result = gr.Textbox(
                            label="컨셉 분석 결과",
                            lines=25,
                            placeholder="'컨셉 분석하기' 버튼을 클릭하세요"
                        )
            
            with gr.Tab("📋 이벤트 생성"):
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("## 📅 기본 정보")
                        event_start_date = gr.Textbox(
                            label="시작일",
                            placeholder="YYYY-MM-DD",
                            value="2025-08-01"
                        )
                        
                        event_end_date = gr.Textbox(
                            label="종료일", 
                            placeholder="YYYY-MM-DD",
                            value="2025-08-10"
                        )
                        
                        event_concept_input = gr.Textbox(
                            label="이벤트 컨셉",
                            placeholder="분석된 컨셉을 선택하거나 직접 입력",
                            info="컨셉 분석 탭에서 선택된 컨셉이 자동 입력됩니다"
                        )
                        
                        gr.Markdown("## 🎁 상품 설정")
                        reward_type_selector = gr.Radio(
                            choices=[
                                "단일 상품",
                                "등급별 상품 (1,2,3등)", 
                                "선택형 상품",
                                "직접 입력"
                            ],
                            label="상품 구성 방식",
                            value="단일 상품"
                        )
                        
                        with gr.Group(visible=True) as single_group:
                            single_type = gr.Dropdown(
                                choices=["네이버페이 금액권", "배달의민족 상품권", "스타벅스 기프트카드", "CGV 영화관람권"],
                                label="상품 종류",
                                value="네이버페이 금액권"
                            )
                            single_amount = gr.Number(label="금액 (원)", value=20000, step=1000)
                            single_frequency = gr.Textbox(
                                label="당첨 주기",
                                value="1시간마다 1명씩 하루 24명"
                            )
                        
                        with gr.Group(visible=False) as grade_group:
                            with gr.Row():
                                grade1_amount = gr.Number(label="1등 금액", value=50000)
                                grade1_count = gr.Number(label="1등 인원", value=5)
                            with gr.Row():
                                grade2_amount = gr.Number(label="2등 금액", value=30000)
                                grade2_count = gr.Number(label="2등 인원", value=10)
                            with gr.Row():
                                grade3_amount = gr.Number(label="3등 금액", value=20000)
                                grade3_count = gr.Number(label="3등 인원", value=20)
                        
                        with gr.Group(visible=False) as choice_group:
                            choice_amount = gr.Number(label="금액 (원)", value=20000)
                            choice_frequency = gr.Textbox(
                                label="당첨 주기",
                                value="1시간마다 1명씩 하루 24명"
                            )
                        
                        with gr.Group(visible=False) as custom_group:
                            custom_reward = gr.Textbox(
                                label="상품 정보 직접 입력",
                                lines=5,
                                placeholder="상품 정보를 자유롭게 입력하세요"
                            )
                        
                        gr.Markdown("## 📞 연락처")
                        phone_number = gr.Textbox(label="고객센터", value="1544-1234")
                        kakao_id = gr.Textbox(label="카카오톡 ID", value="company_kakao")
                        
                        generate_event_btn = gr.Button("✨ 이벤트 생성하기", variant="primary")
                        
                    with gr.Column():
                        with gr.Tabs():
                            with gr.Tab("📋 공지사항"):
                                event_result = gr.Textbox(
                                    label="생성된 이벤트 공지사항",
                                    lines=30,
                                    interactive=False
                                )
                                
                            with gr.Tab("🎨 디자인 가이드"):
                                design_result = gr.Textbox(
                                    label="디자인 가이드",
                                    lines=20,
                                    interactive=False
                                )
            
            with gr.Tab("🔗 API 연동"):
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("## 🌐 외부 API 설정")
                        
                        with gr.Group():
                            gr.Markdown("### 📱 소셜미디어 API")
                            enable_instagram = gr.Checkbox(label="Instagram API 연동", value=False)
                            instagram_token = gr.Textbox(
                                label="Instagram Access Token",
                                type="password",
                                visible=False
                            )
                        
                        with gr.Group():
                            gr.Markdown("### 📊 분석 & AI API")
                            enable_analytics = gr.Checkbox(label="Google Analytics", value=False)
                            ga_tracking_id = gr.Textbox(
                                label="GA Tracking ID",
                                visible=False
                            )
                            
                            enable_chatgpt = gr.Checkbox(label="ChatGPT API (컨셉 생성)", value=False)
                            openai_api_key = gr.Textbox(
                                label="OpenAI API Key",
                                type="password",
                                visible=False
                            )
                        
                        test_api_btn = gr.Button("🔍 API 연결 테스트", variant="secondary")
                        enhance_concept_btn = gr.Button("✨ AI로 컨셉 강화", variant="primary")
                        
                    with gr.Column():
                        api_status = gr.Textbox(
                            label="API 연동 상태",
                            lines=15,
                            placeholder="API 설정 후 연결 테스트를 진행하세요"
                        )
                        
                        ai_enhanced_result = gr.Textbox(
                            label="AI 강화 컨셉",
                            lines=15,
                            placeholder="ChatGPT API로 컨셉을 더욱 창의적으로 발전시킬 수 있습니다"
                        )
        
        concepts_state = gr.State([])
        
        def handle_period_change(period_text):
            month = concept_analyzer.extract_month_from_period(period_text)
            if month:
                return gr.update(value=month)
            return gr.update()
        
        def handle_concept_analysis(month):
            result, concepts = concept_analyzer.analyze_concepts(month)
            return (
                result,
                gr.update(choices=concepts, visible=True, value=concepts[0] if concepts else ""),
                gr.update(visible=True),
                concepts
            )
        
        def handle_concept_selection(concept):
            return gr.update(value=concept)
        
        def handle_custom_concept_change(custom_concept):
            return gr.update(value=custom_concept)
        
        def update_reward_ui(reward_type):
            return (
                gr.update(visible=(reward_type == "단일 상품")),
                gr.update(visible=(reward_type == "등급별 상품 (1,2,3등)")),
                gr.update(visible=(reward_type == "선택형 상품")),
                gr.update(visible=(reward_type == "직접 입력"))
            )
        
        def generate_event_template(start_date, end_date, concept, reward_type, 
                                  single_type, single_amount, single_frequency,
                                  g1_amount, g1_count, g2_amount, g2_count, g3_amount, g3_count,
                                  choice_amount, choice_frequency, custom_reward,
                                  phone, kakao):
            
            if reward_type == "단일 상품":
                reward_structure = f"{single_type} {int(single_amount):,}원\n{single_frequency}"
            elif reward_type == "등급별 상품 (1,2,3등)":
                reward_structure = f"🥇 1등: {int(g1_amount):,}원 ({int(g1_count)}명)\n🥈 2등: {int(g2_amount):,}원 ({int(g2_count)}명)\n🥉 3등: {int(g3_amount):,}원 ({int(g3_count)}명)"
            elif reward_type == "선택형 상품":
                reward_structure = f"네이버페이 or 배달의민족 {int(choice_amount):,}원\n{choice_frequency}"
            else:
                reward_structure = custom_reward
            
            # 컨셉에 따른 트렌디한 카피 생성
            copy_data = concept_analyzer.generate_trendy_copy(concept, "8월")
            
            # 기본 이벤트 템플릿 생성
            event_template = event_manager.generate_detailed_comment_event(
                start_date, end_date, concept, reward_structure, kakao, phone
            )
            
            # 트렌디한 카피를 템플릿 상단에 추가
            trendy_intro = f"""{copy_data['sub1']}

💫 {copy_data['main']} 💫

{copy_data['sub2']}

{' '.join(copy_data['hashtags'])}

---

"""
            
            final_template = trendy_intro + event_template
            
            # 디자인 가이드 생성
            design_guide = event_manager.generate_design_advice(concept)
            
            return final_template, design_guide
        
        def toggle_api_inputs(instagram, analytics, chatgpt):
            return (
                gr.update(visible=instagram),
                gr.update(visible=analytics),
                gr.update(visible=chatgpt)
            )
        
        def test_api_connections(enable_instagram, instagram_token, enable_analytics, ga_tracking_id, enable_chatgpt, openai_api_key):
            return api_integrations.test_all_connections(enable_instagram, instagram_token, enable_analytics, ga_tracking_id, enable_chatgpt, openai_api_key)
        
        def enhance_with_ai(month, openai_key):
            if not openai_key:
                return "OpenAI API Key를 입력해주세요."
            return api_integrations.generate_enhanced_concept_with_chatgpt(month, openai_key)
        
        concept_event_period.change(
            handle_period_change,
            inputs=[concept_event_period],
            outputs=[concept_month]
        )
        
        analyze_concept_btn.click(
            handle_concept_analysis,
            inputs=[concept_month],
            outputs=[concept_result, selected_concept, custom_concept_input, concepts_state]
        )
        
        selected_concept.change(
            handle_concept_selection,
            inputs=[selected_concept],
            outputs=[event_concept_input]
        )
        
        custom_concept_input.change(
            handle_custom_concept_change,
            inputs=[custom_concept_input],
            outputs=[event_concept_input]
        )
        
        reward_type_selector.change(
            update_reward_ui,
            inputs=[reward_type_selector],
            outputs=[single_group, grade_group, choice_group, custom_group]
        )
        
        generate_event_btn.click(
            generate_event_template,
            inputs=[
                event_start_date, event_end_date, event_concept_input, reward_type_selector,
                single_type, single_amount, single_frequency,
                grade1_amount, grade1_count, grade2_amount, grade2_count, grade3_amount, grade3_count,
                choice_amount, choice_frequency, custom_reward,
                phone_number, kakao_id
            ],
            outputs=[event_result, design_result]
        )
        
        for checkbox in [enable_instagram, enable_analytics, enable_chatgpt]:
            checkbox.change(
                toggle_api_inputs,
                inputs=[enable_instagram, enable_analytics, enable_chatgpt],
                outputs=[instagram_token, ga_tracking_id, openai_api_key]
            )
        
        test_api_btn.click(
            test_api_connections,
            inputs=[enable_instagram, instagram_token, enable_analytics, ga_tracking_id, enable_chatgpt, openai_api_key],
            outputs=[api_status]
        )
        
        enhance_concept_btn.click(
            enhance_with_ai,
            inputs=[concept_month, openai_api_key],
            outputs=[ai_enhanced_result]
        )
    
    return demo

if __name__ == "__main__":
    demo = create_interface()
    demo.launch()