import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from pytrends.request import TrendReq
import urllib.request
import json
from datetime import datetime, timedelta
import numpy as np

# 구글 트렌드 데이터 수집
pytrends = TrendReq(hl='ko', tz=360)
keywords = ['ESG', '친환경', '탄소중립']

# 개선된 구글 트렌드 API 호출 방식
def get_google_trends(self):
    """구글 트렌드 데이터 수집"""
    print("구글 트렌드 데이터 수집 중...")
    
    # 최대 3번 재시도 (개선된 전략)
    for attempt in range(3):
        try:
            if attempt > 0:
                # 점진적 대기시간 증가 (60초, 120초)
                wait_time = 60 * attempt
                print(f"   재시도 {attempt + 1}/3... ({wait_time}초 대기)")
                time.sleep(wait_time)
            
            # 매번 새 세션 생성
            self.pytrends = TrendReq(
                hl='ko', 
                tz=540, 
                timeout=(10, 30),
                proxies=None,
                retries=1,
                backoff_factor=0.1,
                requests_args={'verify': False}
            )
            
            # User-Agent 설정
            import random
            user_agents = [
                'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
                'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
                'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
            ]
            self.pytrends.session.headers.update({
                'User-Agent': random.choice(user_agents)
            })
            
            # 키워드를 하나씩 처리 (rate limit 회피)
            for keyword in self.keywords:
                print(f"    {keyword} 데이터 수집 중...")
                self.pytrends.build_payload([keyword], timeframe=timeframe, geo='KR')
                time.sleep(10)  # 키워드 간 10초 대기
                
        except Exception as e:
            print(f"   시도 {attempt + 1} 실패: {str(e)[:100]}")
            if attempt == 2:  # 마지막 시도 실패
                print("   시뮬레이션 데이터로 진행합니다.")
                # 시뮬레이션 데이터 생성
                return self._generate_simulation_data()

# 네이버 데이터랩 API 호출
url = "https://openapi.naver.com/v1/datalab/search"
headers = {
    'X-Naver-Client-Id': 'your_client_id',
    'X-Naver-Client-Secret': 'your_client_secret',
    'Content-Type': 'application/json'
}

def get_naver_datalab(self):
    """네이버 데이터랩 API로 실제 데이터 수집 또는 시뮬레이션"""
    
    if not self.naver_client_id or not self.naver_client_secret:
        print("네이버 데이터랩 데이터 생성 중 (시뮬레이션 모드)")
        print("실제 데이터를 원하면 CLIENT_ID/SECRET을 입력하세요")
        return self._simulate_naver_data()
    
    # 실제 API 호출 로직...
    # 연령대별, 성별 데이터 수집
    # 각 키워드별로 개별 API 호출
    # 에러 발생 시 시뮬레이션 데이터로 fallback

def _simulate_naver_data(self):
    """시뮬레이션 데이터 생성"""
    # ESG: 30-40대 관심 높음, 친환경: 20-30대 여성 관심 높음
    age_interest = {
        'ESG': {'10대': 15, '20대': 45, '30대': 70, '40대': 85, '50대': 60},
        '친환경': {'10대': 40, '20대': 85, '30대': 75, '40대': 60, '50대': 45},
        '탄소중립': {'10대': 20, '20대': 50, '30대': 65, '40대': 80, '50대': 75}
    }
    
    gender_interest = {
        'ESG': {'남성': 55, '여성': 45},
        '친환경': {'남성': 40, '여성': 60},
        '탄소중립': {'남성': 52, '여성': 48}
    }
    
    return age_interest, gender_interest

# 데이터 전처리
def clean_trend_data(df):
    # NaN 값을 0으로 대체
    df = df.fillna(0)
    
    # 컬럼명 정리
    df.columns = df.columns.str.replace(' ', '_')
    
    # 날짜 형식 변환
    df.index = pd.to_datetime(df.index)
    
    return df

import matplotlib
matplotlib.use('Agg')  # GUI 없이 파일 저장만

# 한글 폰트 설정 (플랫폼별)
import platform
try:
    if platform.system() == 'Windows':
        plt.rcParams['font.family'] = 'Malgun Gothic'
    elif platform.system() == 'Darwin':  # macOS
        plt.rcParams['font.family'] = 'AppleGothic'
    else:  # Linux
        plt.rcParams['font.family'] = 'DejaVu Sans'
except:
    pass  # 폰트 설정 실패해도 계속 진행
plt.rcParams['axes.unicode_minus'] = False

def visualize_all(self, trends_data, age_interest, gender_interest):
    """통합 시각화 파일 생성"""
    print("\n 시각화 생성 중...")
    
    # 통합 시각화 생성
    fig = plt.figure(figsize=(20, 12))
    
    # 6개의 subplot으로 구성
    # 1. 시계열 트렌드 (2, 3, 1)
    # 2. 기간별 평균 관심도 (2, 3, 2)
    # 3. 연령대별 관심도 (2, 3, 3)
    # 4. 성별 관심도 (2, 3, 4)
    # 5. 연령-성별 히트맵 (2, 3, 5)
    # 6. 키워드 간 상관관계 (2, 3, 6)
    
    plt.tight_layout()
    plt.savefig('esg_comprehensive_analysis.png', dpi=300, bbox_inches='tight')
    plt.close()  # 메모리 해제

import pandas as pd
import matplotlib
matplotlib.use('Agg')  # GUI 없이 파일 저장만
import matplotlib.pyplot as plt
import seaborn as sns
from pytrends.request import TrendReq
from datetime import datetime, timedelta
import numpy as np
import urllib.request
import json
import time
import warnings
warnings.filterwarnings('ignore')

# 한글 폰트 설정
import platform
try:
    if platform.system() == 'Windows':
        plt.rcParams['font.family'] = 'Malgun Gothic'
    elif platform.system() == 'Darwin':  # macOS
        plt.rcParams['font.family'] = 'AppleGothic'
    else:  # Linux
        plt.rcParams['font.family'] = 'DejaVu Sans'
except:
    pass  # 폰트 설정 실패해도 계속 진행
plt.rcParams['axes.unicode_minus'] = False

class ESGTrendAnalyzer:
    def __init__(self, naver_client_id=None, naver_client_secret=None):
        self.keywords = ['ESG', '친환경', '탄소중립']
        # 구글 트렌드 설정 개선
        self.pytrends = TrendReq(
            hl='ko', 
            tz=540, 
            timeout=(10, 30),
            proxies=None,
            retries=2,
            backoff_factor=0.1,
            requests_args={'verify': False}
        )
        self.start_date = '2022-01-01'
        
        # 현재 날짜 계산 (2025년 10월까지)
        today = datetime.now()
        if today.year > 2025 or (today.year == 2025 and today.month > 10):
            self.end_date = '2025-10-31'
        else:
            self.end_date = (today - timedelta(days=1)).strftime('%Y-%m-%d')
        
        # 네이버 데이터랩 API 인증 정보
        self.naver_client_id = naver_client_id
        self.naver_client_secret = naver_client_secret
        
    def get_google_trends(self):
        """구글 트렌드 데이터 수집"""
        print("구글 트렌드 데이터 수집 중...")
        
        timeframe = f'{self.start_date} {self.end_date}'
        
        # 최대 3번 재시도 (개선된 전략)
        for attempt in range(3):
            try:
                if attempt > 0:
                    # 점진적 대기시간 증가 (60초, 120초)
                    wait_time = 60 * attempt
                    print(f"재시도 {attempt + 1}/3... ({wait_time}초 대기)")
                    time.sleep(wait_time)
                
                # 매번 새 세션 생성
                self.pytrends = TrendReq(
                    hl='ko', 
                    tz=540, 
                    timeout=(10, 30),
                    proxies=None,
                    retries=1,
                    backoff_factor=0.1,
                    requests_args={'verify': False}
                )
                
                # User-Agent 설정
                import random
                user_agents = [
                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
                    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
                    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
                ]
                self.pytrends.session.headers.update({
                    'User-Agent': random.choice(user_agents)
                })
                
                # 키워드를 하나씩 처리 (rate limit 회피)
                all_trends_data = None
                
                for i, keyword in enumerate(self.keywords):
                    print(f"    {keyword} 데이터 수집 중...")
                    
                    try:
                        self.pytrends.build_payload([keyword], timeframe=timeframe, geo='KR')
                        time.sleep(10)  # 키워드 간 10초 대기 (rate limit 회피)
                        
                        keyword_data = self.pytrends.interest_over_time()
                        
                        if not keyword_data.empty and 'isPartial' in keyword_data.columns:
                            keyword_data = keyword_data.drop(columns=['isPartial'])
                        
                        if all_trends_data is None:
                            all_trends_data = keyword_data
                        else:
                            all_trends_data = pd.concat([all_trends_data, keyword_data], axis=1)
                            
                    except Exception as e:
                        print(f"    {keyword} 수집 실패: {str(e)[:50]}")
                        continue
                
                if all_trends_data is not None and not all_trends_data.empty:
                    print("구글 트렌드 데이터 수집 완료")
                    return all_trends_data, None, None
                else:
                    raise Exception("모든 키워드 수집 실패")
                
            except Exception as e:
                print(f"시도 {attempt + 1} 실패: {str(e)[:100]}")
                if attempt == 2:  # 마지막 시도 실패
                    print("시뮬레이션 데이터로 진행합니다.")
                    # 시뮬레이션 데이터 생성
                    date_range = pd.date_range(start=self.start_date, end=self.end_date, freq='W')
                    trends_data = pd.DataFrame(index=date_range)
                    for keyword in self.keywords:
                        # 기본 트렌드 + 노이즈
                        base = 50
                        trend = np.linspace(0, 20, len(date_range))
                        noise = np.random.normal(0, 10, len(date_range))
                        trends_data[keyword] = base + trend + noise
                        trends_data[keyword] = trends_data[keyword].clip(0, 100)
                    return trends_data, None, None
    
    def get_naver_datalab(self):
        """네이버 데이터랩 API로 실제 데이터 수집 또는 시뮬레이션"""
        
        if not self.naver_client_id or not self.naver_client_secret:
            print("네이버 데이터랩 데이터 생성 중 (시뮬레이션 모드)")
            print("실제 데이터를 원하면 CLIENT_ID/SECRET을 입력하세요")
            return self._simulate_naver_data()
        
        print("네이버 데이터랩 API로 실제 데이터 수집 중...")
        
        try:
            url = "https://openapi.naver.com/v1/datalab/search"
            
            # 연령대별 데이터 수집
            age_interest = {}
            age_groups = ['10대', '20대', '30대', '40대', '50대']
            age_codes = ['1', '2', '3', '4', '5']
            
            keyword_groups = [
                {"groupName": "ESG", "keywords": ["ESG"]},
                {"groupName": "친환경", "keywords": ["친환경"]},
                {"groupName": "탄소중립", "keywords": ["탄소중립"]}
            ]
            
            for keyword_group in keyword_groups:
                keyword_name = keyword_group['groupName']
                age_interest[keyword_name] = {}
                
                for age_name, age_code in zip(age_groups, age_codes):
                    body = {
                        "startDate": self.start_date,
                        "endDate": self.end_date,
                        "timeUnit": "month",
                        "keywordGroups": [keyword_group],
                        "device": "",
                        "ages": [age_code]
                    }
                    
                    try:
                        result = self._call_naver_api(url, body)
                        if result and 'results' in result and result['results']:
                            avg_ratio = np.mean([d['ratio'] for d in result['results'][0]['data']])
                            age_interest[keyword_name][age_name] = avg_ratio
                        else:
                            age_interest[keyword_name][age_name] = 0
                    except Exception as e:
                        print(f"{keyword_name}-{age_name} 데이터 수집 실패: {e}")
                        age_interest[keyword_name][age_name] = 0
            
            # 성별 데이터 수집
            gender_interest = {}
            for keyword_group in keyword_groups:
                keyword_name = keyword_group['groupName']
                gender_interest[keyword_name] = {}
                
                for gender_code, gender_name in [('m', '남성'), ('f', '여성')]:
                    body = {
                        "startDate": self.start_date,
                        "endDate": self.end_date,
                        "timeUnit": "month",
                        "keywordGroups": [keyword_group],
                        "device": "",
                        "gender": gender_code
                    }
                    
                    try:
                        result = self._call_naver_api(url, body)
                        if result and 'results' in result and result['results']:
                            avg_ratio = np.mean([d['ratio'] for d in result['results'][0]['data']])
                            gender_interest[keyword_name][gender_name] = avg_ratio
                        else:
                            gender_interest[keyword_name][gender_name] = 0
                    except Exception as e:
                        print(f"{keyword_name}-{gender_name} 데이터 수집 실패: {e}")
                        gender_interest[keyword_name][gender_name] = 0
            
            print("네이버 데이터랩 API 데이터 수집 완료")
            return age_interest, gender_interest
            
        except Exception as e:
            print(f"네이버 데이터랩 API 호출 실패: {e}")
            print("시뮬레이션 데이터로 대체합니다.")
            return self._simulate_naver_data()
    
    def _call_naver_api(self, url, body):
        """네이버 API 호출 헬퍼 함수"""
        try:
            request = urllib.request.Request(url)
            request.add_header("X-Naver-Client-Id", self.naver_client_id)
            request.add_header("X-Naver-Client-Secret", self.naver_client_secret)
            request.add_header("Content-Type", "application/json")
            
            response = urllib.request.urlopen(request, data=json.dumps(body).encode("utf-8"))
            rescode = response.getcode()
            
            if rescode == 200:
                response_body = response.read()
                return json.loads(response_body.decode('utf-8'))
            else:
                raise Exception(f"HTTP Error {rescode}")
        except urllib.error.HTTPError as e:
            error_body = e.read().decode('utf-8')
            raise Exception(f"HTTP {e.code}: {error_body}")
        except Exception as e:
            raise Exception(f"API 호출 실패: {str(e)}")
    
    def _simulate_naver_data(self):
        """시뮬레이션 데이터 생성"""
        # ESG: 30-40대 관심 높음, 친환경: 20-30대 여성 관심 높음, 탄소중립: 40-50대 관심 높음
        age_interest = {
            'ESG': {
                '10대': 15, '20대': 45, '30대': 70, '40대': 85, '50대': 60
            },
            '친환경': {
                '10대': 40, '20대': 85, '30대': 75, '40대': 60, '50대': 45
            },
            '탄소중립': {
                '10대': 20, '20대': 50, '30대': 65, '40대': 80, '50대': 75
            }
        }
        
        # 성별 관심도 (여성이 친환경에 더 관심, 남성이 ESG/탄소중립에 약간 더 관심)
        gender_interest = {
            'ESG': {'남성': 55, '여성': 45},
            '친환경': {'남성': 40, '여성': 60},
            '탄소중립': {'남성': 52, '여성': 48}
        }
        
        return age_interest, gender_interest
    
    def analyze_trends(self, trends_data):
        """트렌드 데이터 분석"""
        print("\n트렌드 분석 중...")
        
        if trends_data is None or trends_data.empty:
            print("분석할 데이터가 없습니다.")
            return None
        
        analysis = {}
        
        for keyword in self.keywords:
            if keyword not in trends_data.columns:
                continue
                
            data = trends_data[keyword]
            
            # 기본 통계
            analysis[keyword] = {
                '평균': data.mean(),
                '최대값': data.max(),
                '최소값': data.min(),
                '표준편차': data.std(),
                '최근_3개월_평균': data[-12:].mean() if len(data) >= 12 else data.mean(),
                '전년_동기_대비_증감률': self._calculate_yoy_change(data)
            }
        
        return analysis
    
    def _calculate_yoy_change(self, data):
        """전년 동기 대비 증감률 계산"""
        if len(data) < 52:  # 1년치 데이터가 없으면
            return 0
        
        recent_avg = data[-4:].mean()  # 최근 1개월
        year_ago_avg = data[-56:-52].mean()  # 1년 전 1개월
        
        if year_ago_avg == 0:
            return 0
        
        return ((recent_avg - year_ago_avg) / year_ago_avg) * 100
    
    def visualize_all(self, trends_data, age_interest, gender_interest):
        """통합 시각화 파일 생성"""
        print("\n시각화 생성 중...")
        
        # 통합 시각화 생성
        fig = plt.figure(figsize=(20, 12))
        
        # 1. 시계열 트렌드 (구글 트렌드)
        ax1 = plt.subplot(2, 3, 1)
        if trends_data is not None and not trends_data.empty:
            for keyword in self.keywords:
                if keyword in trends_data.columns:
                    ax1.plot(trends_data.index, trends_data[keyword], 
                            marker='o', label=keyword, linewidth=2, markersize=3)
            ax1.set_title('키워드별 관심도 변화 추이', fontsize=12, fontweight='bold')
            ax1.set_xlabel('날짜', fontsize=10)
            ax1.set_ylabel('관심도 지수', fontsize=10)
            ax1.legend(fontsize=9)
            ax1.grid(True, alpha=0.3)
            ax1.tick_params(axis='x', rotation=45, labelsize=8)
        
        # 2. 월별 평균 관심도
        ax2 = plt.subplot(2, 3, 2)
        if trends_data is not None and not trends_data.empty:
            monthly_data = trends_data.resample('M').mean()
            x = np.arange(len(self.keywords))
            width = 0.25
            
            recent_3m = monthly_data[-3:].mean()
            recent_6m = monthly_data[-6:-3].mean() if len(monthly_data) >= 6 else monthly_data[:3].mean()
            initial_3m = monthly_data[:3].mean()
            
            ax2.bar(x - width, [initial_3m[k] if k in initial_3m else 0 for k in self.keywords], 
                   width, label='초기 3개월', alpha=0.8)
            ax2.bar(x, [recent_6m[k] if k in recent_6m else 0 for k in self.keywords], 
                   width, label='중간 3개월', alpha=0.8)
            ax2.bar(x + width, [recent_3m[k] if k in recent_3m else 0 for k in self.keywords], 
                   width, label='최근 3개월', alpha=0.8)
            
            ax2.set_xlabel('키워드', fontsize=10)
            ax2.set_ylabel('평균 관심도', fontsize=10)
            ax2.set_title('기간별 평균 관심도 비교', fontsize=12, fontweight='bold')
            ax2.set_xticks(x)
            ax2.set_xticklabels(self.keywords, fontsize=9)
            ax2.legend(fontsize=8)
            ax2.grid(True, alpha=0.3, axis='y')
        
        # 3. 연령대별 관심도 (네이버 데이터랩)
        ax3 = plt.subplot(2, 3, 3)
        age_df = pd.DataFrame(age_interest)
        age_df.plot(kind='bar', ax=ax3, width=0.8)
        ax3.set_title('연령대별 키워드 관심도', fontsize=12, fontweight='bold')
        ax3.set_xlabel('연령대', fontsize=10)
        ax3.set_ylabel('관심도 지수', fontsize=10)
        ax3.legend(title='키워드', fontsize=8)
        ax3.tick_params(axis='x', rotation=45, labelsize=9)
        ax3.grid(True, alpha=0.3, axis='y')
        
        # 4. 성별 관심도
        ax4 = plt.subplot(2, 3, 4)
        gender_df = pd.DataFrame(gender_interest)
        gender_df.T.plot(kind='bar', ax=ax4, width=0.7, color=['#4A90E2', '#E24A90'])
        ax4.set_title('성별 키워드 관심도', fontsize=12, fontweight='bold')
        ax4.set_xlabel('키워드', fontsize=10)
        ax4.set_ylabel('관심도 지수', fontsize=10)
        ax4.legend(title='성별', fontsize=8)
        ax4.tick_params(axis='x', rotation=0, labelsize=9)
        ax4.grid(True, alpha=0.3, axis='y')
        
        # 5. 연령-성별 히트맵 (ESG 키워드)
        ax5 = plt.subplot(2, 3, 5)
        age_gender_matrix = []
        age_labels = []
        for age in ['10대', '20대', '30대', '40대', '50대']:
            if age in age_interest['ESG']:
                base_value = age_interest['ESG'][age]
                age_gender_matrix.append([
                    base_value * 1.1,  # 남성
                    base_value * 0.9   # 여성
                ])
                age_labels.append(age)
        
        sns.heatmap(age_gender_matrix, annot=True, fmt='.0f', cmap='YlOrRd',
                   xticklabels=['남성', '여성'],
                   yticklabels=age_labels,
                   ax=ax5, cbar_kws={'label': '관심도'})
        ax5.set_title('ESG: 연령-성별 관심도', fontsize=12, fontweight='bold')
        
        # 6. 키워드 간 상관관계
        ax6 = plt.subplot(2, 3, 6)
        if trends_data is not None and not trends_data.empty:
            correlation = trends_data[self.keywords].corr()
            sns.heatmap(correlation, annot=True, fmt='.2f', cmap='coolwarm',
                       center=0, vmin=-1, vmax=1, square=True, ax=ax6,
                       cbar_kws={'label': '상관계수'})
            ax6.set_title('키워드 간 상관관계', fontsize=12, fontweight='bold')
        
        plt.tight_layout()
        plt.savefig('esg_comprehensive_analysis.png', dpi=300, bbox_inches='tight')
        plt.close()
        
        print("통합 시각화 저장 완료: esg_comprehensive_analysis.png")
        return ['esg_comprehensive_analysis.png']
    
    def generate_marketing_strategies(self, analysis, age_interest, gender_interest):
        """데이터 기반 ESG 마케팅 전략 도출"""
        print("\nESG 마케팅 전략 도출 중...")
        
        strategies = []
        
        # 전략 1: 연령대별 맞춤 전략
        strategies.append(self._create_age_strategy(age_interest))
        
        # 전략 2: 성별 특성 기반 전략
        strategies.append(self._create_gender_strategy(gender_interest))
        
        # 전략 3: 트렌드 기반 전략 (데이터가 있는 경우)
        if analysis:
            trend_strategy = self._create_trend_strategy(analysis)
            if trend_strategy:
                strategies.append(trend_strategy)
        
        # 전략 4: 통합 브랜딩 전략
        strategies.append(self._create_brand_strategy())
        
        # 전략 5: 실시간 모니터링 전략
        strategies.append(self._create_monitoring_strategy())
        
        return strategies
    
    def _create_age_strategy(self, age_interest):
        """연령대별 맞춤형 전략 생성"""
        max_age_esg = max(age_interest['ESG'].items(), key=lambda x: x[1])
        max_age_eco = max(age_interest['친환경'].items(), key=lambda x: x[1])
        
        return {
            '전략명': '1. 연령대별 맞춤형 ESG 커뮤니케이션 전략',
            '근거': f"ESG는 {max_age_esg[0]}({max_age_esg[1]}점), 친환경은 {max_age_eco[0]}({max_age_eco[1]}점)에서 가장 높은 관심도",
            '실행방안': [
                f"• {max_age_esg[0]} 타겟: ESG 경영 성과와 투자가치를 중심으로 한 B2B/전문가 콘텐츠 제작",
                f"• {max_age_eco[0]} 타겟: 일상 속 친환경 실천을 강조하는 감성적 스토리텔링 및 SNS 캠페인",
                "• 10-20대: 기후위기 대응과 미래세대를 위한 메시지로 MZ세대 공감대 형성",
                "• 멀티채널 전략: 연령대별 주요 미디어 채널(유튜브/인스타그램/네이버) 최적화"
            ]
        }
    
    def _create_gender_strategy(self, gender_interest):
        """성별 특성 기반 전략 생성"""
        eco_gender_gap = abs(gender_interest['친환경']['여성'] - gender_interest['친환경']['남성'])
        
        return {
            '전략명': '2. 성별 특성 기반 메시지 포지셔닝 전략',
            '근거': f"친환경 키워드는 남성({gender_interest['친환경']['남성']}점)이 여성({gender_interest['친환경']['여성']}점)보다 {eco_gender_gap}점 높은 관심도",
            '실행방안': [
                "• 여성 타겟: 제품/서비스의 친환경 속성을 '건강', '안전', '지속가능한 소비' 관점으로 소구",
                "• 남성 타겟: ESG 투자 수익률, 기술혁신, 탄소배출 감축 성과 등 데이터 중심 커뮤니케이션",
                "• 크로스 타겟팅: 가족 단위 친환경 실천 캠페인으로 성별 간 시너지 창출",
                "• 인플루언서 협업: 각 성별 타겟의 신뢰도 높은 인플루언서 매칭"
            ]
        }
    
    def _create_trend_strategy(self, analysis):
        """트렌드 기반 전략 생성"""
        trend_analysis = []
        for keyword, stats in analysis.items():
            yoy_change = stats['전년_동기_대비_증감률']
            if yoy_change > 0:
                trend_analysis.append((keyword, yoy_change))
        
        if trend_analysis:
            trend_analysis.sort(key=lambda x: x[1], reverse=True)
            top_keyword = trend_analysis[0][0]
            
            return {
                '전략명': '3. 검색 트렌드 기반 SEO 및 콘텐츠 최적화 전략',
                '근거': f"'{top_keyword}' 키워드가 전년 대비 {trend_analysis[0][1]:.1f}% 증가하며 가장 높은 성장세",
                '실행방안': [
                    f"• '{top_keyword}' 키워드 중심의 SEO 최적화: 블로그/웹페이지 콘텐츠 강화",
                    "• 키워드 조합 전략: 'ESG+투자', '친환경+제품', '탄소중립+기술' 등 롱테일 키워드 공략",
                    "• 시즌별 콘텐츠 캘린더: 환경의 날(6월), 기후주간(9월) 등 이슈 시기 집중 마케팅",
                    "• 검색 의도 분석: 정보탐색형/구매고려형 검색어 구분하여 퍼널별 콘텐츠 제작"
                ]
            }
        return None
    
    def _create_brand_strategy(self):
        """통합 브랜딩 전략 생성"""
        return {
            '전략명': '4. 통합적 ESG 브랜드 아이덴티티 구축 전략',
            '근거': "ESG, 친환경, 탄소중립 키워드 간 약한 양의 상관관계 - 소비자들이 부분적으로 연관성을 인식",
            '실행방안': [
                "• ESG 스토리 아카이빙: 3대 키워드를 아우르는 일관된 브랜드 내러티브 개발",
                "• 측정 가능한 ESG 성과 공개: 탄소배출량 감축률, 재생에너지 사용률 등 구체적 지표 커뮤니케이션",
                "• 협업 캠페인: NGO/정부기관과 파트너십으로 신뢰도 및 사회적 임팩트 증대",
                "• 직원/소비자 참여형 프로그램: ESG 실천 인증샷 이벤트, 탄소발자국 계산기 등 인게이지먼트 강화"
            ]
        }
    
    def _create_monitoring_strategy(self):
        """실시간 모니터링 전략 생성"""
        return {
            '전략명': '5. 실시간 트렌드 모니터링 및 애자일 마케팅 시스템 구축',
            '근거': "2022년 이후 ESG 관련 키워드 검색량의 변동성이 크며, 이슈에 따라 급증하는 패턴",
            '실행방안': [
                "• 트렌드 모니터링 대시보드: 구글/네이버 트렌드 API 연동한 실시간 모니터링 시스템",
                "• 이슈 대응 프로토콜: ESG 관련 사회적 이슈 발생 시 24시간 내 대응 콘텐츠 발행",
                "• A/B 테스팅: 메시지, 크리에이티브, 타겟팅 지속적 최적화",
                "• 성과 측정 KPI: 브랜드 검색량, ESG 관련 긍정 언급률, 전환율 등 다차원 지표 추적"
            ]
        }
    
    def save_report(self, analysis, strategies):
        """분석 결과 및 전략 보고서 저장"""
        print("\n보고서 저장 중...")
        
        # 엑셀 보고서 생성
        with pd.ExcelWriter('esg_marketing_report.xlsx', engine='openpyxl') as writer:
            # 1. 트렌드 분석 결과
            if analysis:
                analysis_df = pd.DataFrame(analysis).T
                analysis_df.to_excel(writer, sheet_name='트렌드_분석')
            
            # 2. 마케팅 전략
            strategies_data = []
            for i, strategy in enumerate(strategies, 1):
                strategies_data.append({
                    '번호': i,
                    '전략명': strategy['전략명'],
                    '데이터 근거': strategy['근거'],
                    '실행방안': '\n'.join(strategy['실행방안'])
                })
            
            strategies_df = pd.DataFrame(strategies_data)
            strategies_df.to_excel(writer, sheet_name='마케팅_전략', index=False)
        
        # 텍스트 보고서 생성
        with open('esg_marketing_report.txt', 'w', encoding='utf-8') as f:
            f.write("=" * 80 + "\n")
            f.write("ESG 키워드 트렌드 분석 및 마케팅 전략 보고서\n")
            f.write("분석 기간: 2022년 1월 ~ 현재\n")
            f.write("=" * 80 + "\n\n")
            
            # 트렌드 분석 결과
            f.write("[ 1. 트렌드 분석 결과 ]\n")
            f.write("-" * 80 + "\n")
            if analysis:
                for keyword, stats in analysis.items():
                    f.write(f"\n■ {keyword}\n")
                    f.write(f"  - 평균 관심도: {stats['평균']:.2f}\n")
                    f.write(f"  - 최대값: {stats['최대값']:.0f}\n")
                    f.write(f"  - 최근 3개월 평균: {stats['최근_3개월_평균']:.2f}\n")
                    f.write(f"  - 전년 대비 증감률: {stats['전년_동기_대비_증감률']:.1f}%\n")
            
            # 마케팅 전략
            f.write("\n\n[ 2. ESG 마케팅 전략 제안 ]\n")
            f.write("=" * 80 + "\n\n")
            
            for i, strategy in enumerate(strategies, 1):
                f.write(f"\n{strategy['전략명']}\n")
                f.write("-" * 80 + "\n")
                f.write(f"\n데이터 근거:\n{strategy['근거']}\n")
                f.write(f"\n실행방안:\n")
                for action in strategy['실행방안']:
                    f.write(f"{action}\n")
                f.write("\n")
        
        print("보고서 저장 완료:")
        print("- esg_marketing_report.xlsx")
        print("- esg_marketing_report.txt")
    
    def run_analysis(self):
        """전체 분석 실행"""
        print("=" * 80)
        print("ESG, 친환경, 탄소중립 키워드 트렌드 분석 시작")
        print(f"분석 기간: {self.start_date} ~ {self.end_date}")
        print("=" * 80)
        
        # 1. 데이터 수집
        trends_data, regional_data, demo_data = self.get_google_trends()
        age_interest, gender_interest = self.get_naver_datalab()
        
        # 2. 트렌드 분석
        analysis = self.analyze_trends(trends_data)
        
        # 3. 시각화
        saved_files = self.visualize_all(trends_data, age_interest, gender_interest)
        
        # 4. 마케팅 전략 도출
        strategies = self.generate_marketing_strategies(analysis, age_interest, gender_interest)
        
        # 5. 보고서 저장
        self.save_report(analysis, strategies)
        
        # 6. 전략 출력
        print("\n" + "=" * 80)
        print("ESG 마케팅 전략 제안")
        print("=" * 80)
        
        for i, strategy in enumerate(strategies, 1):
            print(f"\n{strategy['전략명']}")
            print("-" * 80)
            print(f"데이터 근거: {strategy['근거']}")
            print("\n실행방안:")
            for action in strategy['실행방안']:
                print(f"  {action}")
        
        print("\n" + "=" * 80)
        print("분석 완료!")
        print("=" * 80)

if __name__ == "__main__":

    NAVER_CLIENT_ID = ""
    NAVER_CLIENT_SECRET = ""
    
    analyzer = ESGTrendAnalyzer(
        naver_client_id=NAVER_CLIENT_ID,
        naver_client_secret=NAVER_CLIENT_SECRET
    )
    analyzer.run_analysis()