ds_new_user_analy/retention_analysis.py

#!/usr/bin/env python3
"""
Retention Analysis Script v2.0
던전 스토커즈 신규 유저 리텐션 분석 도구

사용법: python retention_analysis.py [CSV_파일_경로]
설정: retention_analysis_config.json
"""

import pandas as pd
import numpy as np
from scipy import stats
from scipy.stats import spearmanr
import sys
import os
import json
import logging
from datetime import datetime
from sklearn.ensemble import RandomForestClassifier
from tqdm import tqdm
import warnings

warnings.filterwarnings('ignore')

class RetentionAnalyzer:
    def __init__(self, csv_path, config_path='retention_analysis_config.json'):
        """
        초기화
        
        Parameters:
        -----------
        csv_path : str
            분석할 CSV 파일 경로
        config_path : str
            설정 파일 경로
        """
        self.csv_path = csv_path
        self.config = self.load_config(config_path)
        self.df = None
        self.correlation_results = {}
        self.feature_importance = {}
        self.console_log = []
        
        # 출력 디렉토리 설정
        self.output_dir = 'analysis_results'
        os.makedirs(self.output_dir, exist_ok=True)
        
        # 타임스탬프
        self.timestamp = datetime.now().strftime(self.config['output_settings']['timestamp_format'])
        
        # 로깅 설정
        self.setup_logging()
        
    def setup_logging(self):
        """로깅 시스템 초기화"""
        log_filename = f"{self.output_dir}/retention_analysis_{self.timestamp}.log"
        
        # 콘솔과 파일에 동시 로깅
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s [%(levelname)s] %(message)s',
            handlers=[
                logging.FileHandler(log_filename, encoding='utf-8'),
                logging.StreamHandler(sys.stdout)
            ]
        )
        self.logger = logging.getLogger(__name__)
        
    def load_config(self, config_path):
        """설정 파일 로드"""
        try:
            with open(config_path, 'r', encoding='utf-8') as f:
                config = json.load(f)
            return config
        except FileNotFoundError:
            print(f"Warning: {config_path} 파일을 찾을 수 없습니다. 기본 설정을 사용합니다.")
            return self.get_default_config()
        except json.JSONDecodeError as e:
            print(f"Error: {config_path} 파일 형식이 올바르지 않습니다: {e}")
            return self.get_default_config()
    
    def get_default_config(self):
        """기본 설정 반환"""
        return {
            "analysis_settings": {
                "correlation_threshold": 0.05,
                "top_n_features": 20,
                "min_sample_size": 10
            },
            "retention_groups": [
                "Retained_d0", "Retained_d1", "Retained_d2", "Retained_d3",
                "Retained_d4", "Retained_d5", "Retained_d6", "Retained_d7+"
            ],
            "exclude_columns": [
                "uid", "retention_status", "retention_encoded", 
                "country", "nickname", "auth_id"
            ],
            "key_metrics_for_d0_analysis": [
                "tutorial_complete", "level_up_count", "play_time_total",
                "COOP_entry_count", "Solo_entry_count", 
                "death_Monster", "death_Trap", "death_PK",
                "item_gain_Equipment", "gold_gain_total"
            ],
            "output_settings": {
                "save_csv": True,
                "save_markdown": True,
                "save_console_log": True,
                "timestamp_format": "%Y%m%d_%H%M%S"
            }
        }
    
    def log_message(self, stage, message, level="INFO"):
        """구조화된 로그 메시지"""
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        formatted_msg = f"[{timestamp}] [{stage}] {level}: {message}"
        
        if level == "INFO":
            self.logger.info(f"[{stage}] {message}")
        elif level == "WARNING":
            self.logger.warning(f"[{stage}] {message}")
        elif level == "ERROR":
            self.logger.error(f"[{stage}] {message}")
            
        self.console_log.append(formatted_msg)
    
    def validate_csv(self):
        """CSV 파일 유효성 검사"""
        self.log_message("VALIDATION", "CSV 파일 유효성 검사 시작")
        
        if not os.path.exists(self.csv_path):
            raise FileNotFoundError(f"파일을 찾을 수 없습니다: {self.csv_path}")
        
        # 필수 컬럼 검사
        try:
            sample_df = pd.read_csv(self.csv_path, nrows=5)
            required_cols = ['uid', 'retention_status']
            
            missing_cols = [col for col in required_cols if col not in sample_df.columns]
            if missing_cols:
                raise ValueError(f"필수 컬럼이 없습니다: {missing_cols}")
            
            # retention_status 값 검사
            retention_groups = set(self.config['retention_groups'])
            sample_retention = set(sample_df['retention_status'].dropna().unique())
            
            if not sample_retention.issubset(retention_groups):
                invalid_values = sample_retention - retention_groups
                self.log_message("VALIDATION", 
                               f"예상치 못한 retention_status 값: {invalid_values}", 
                               "WARNING")
                
            self.log_message("VALIDATION", "CSV 파일 유효성 검사 완료 OK")
            
        except Exception as e:
            raise ValueError(f"CSV 파일 검증 실패: {str(e)}")
    
    def load_data(self):
        """CSV 데이터 로드 및 기본 전처리"""
        self.log_message("LOAD", "데이터 로딩 시작")
        
        # 파일 크기 확인
        file_size = os.path.getsize(self.csv_path) / (1024 * 1024)  # MB
        self.log_message("LOAD", f"파일 크기: {file_size:.1f} MB")
        
        # 진행률 바와 함께 데이터 로드
        with tqdm(desc="데이터 로딩 중", unit="MB") as pbar:
            self.df = pd.read_csv(self.csv_path)
            pbar.update(file_size)
        
        self.log_message("LOAD", f"데이터 로드 완료: {len(self.df):,} rows, {len(self.df.columns)} columns")
        
        # 분석 기간 정보 추출 (create_time 기반)
        self.analysis_period_info = self.extract_analysis_period()
        
        # retention_status를 순서형 변수로 인코딩
        retention_groups = self.config['retention_groups']
        self.df['retention_encoded'] = self.df['retention_status'].map(
            {status: i for i, status in enumerate(retention_groups)}
        )
        
        # 기본 정보 출력
        self.log_message("STATS", "=== 데이터 기본 정보 ===")
        self.log_message("STATS", f"총 유저 수: {len(self.df):,}")
        
        # 분석 기간 정보 출력
        if self.analysis_period_info['valid']:
            self.log_message("STATS", f"분석 기간: {self.analysis_period_info['start_date']} ~ {self.analysis_period_info['end_date']}")
            self.log_message("STATS", f"분석 대상 기간: {self.analysis_period_info['total_days']}일")
            self.log_message("STATS", f"일평균 신규 가입: {self.analysis_period_info['avg_daily_signups']:.1f}명")
        
        self.log_message("STATS", "")
        self.log_message("STATS", "Retention 분포:")
        
        retention_dist = self.df['retention_status'].value_counts()
        for status in retention_groups:
            if status in retention_dist.index:
                count = retention_dist[status]
                pct = count / len(self.df) * 100
                self.log_message("STATS", f"  {status}: {count:,} ({pct:.1f}%)")
        
        # D0 이탈률 강조
        d0_rate = retention_dist.get('Retained_d0', 0) / len(self.df) * 100
        self.log_message("STATS", "")
        self.log_message("STATS", f"CRITICAL: D0 이탈률: {d0_rate:.1f}%", "WARNING")
        
        return self.df
    
    def extract_analysis_period(self):
        """분석 기간 정보 추출 (ISO 8601 형식 create_time 처리)"""
        try:
            # create_time 컬럼이 있는지 확인
            if 'create_time' not in self.df.columns:
                self.log_message("PERIOD", "create_time 컬럼이 없습니다. 기간 분석을 생략합니다.", "WARNING")
                return {'valid': False}
            
            # ISO 8601 형식 (2025-08-13T20:14:43+09:00)을 datetime으로 변환
            # 빈 값이 없다고 했으므로 errors='raise'로 설정하여 문제 발견 시 즉시 알림
            create_times = pd.to_datetime(self.df['create_time'], format='ISO8601')
            
            # 기간 정보 계산
            start_date = create_times.min()
            end_date = create_times.max()
            total_days = (end_date - start_date).days + 1
            
            # 일별 가입자 분포 (한국 시간 기준으로 날짜 추출)
            korea_dates = create_times.dt.tz_convert('Asia/Seoul').dt.date
            daily_signups = korea_dates.value_counts().sort_index()
            avg_daily_signups = len(create_times) / total_days if total_days > 0 else 0
            
            # 시간대별 가입 패턴 분석 (추가 인사이트)
            korea_hours = create_times.dt.tz_convert('Asia/Seoul').dt.hour
            hourly_signups = korea_hours.value_counts().sort_index()
            peak_hour = hourly_signups.idxmax()
            
            # 요일별 가입 패턴 (0=월요일, 6=일요일)
            korea_weekdays = create_times.dt.tz_convert('Asia/Seoul').dt.dayofweek
            weekday_signups = korea_weekdays.value_counts().sort_index()
            weekday_names = ['월', '화', '수', '목', '금', '토', '일']
            
            self.log_message("PERIOD", f"가입 집중 시간: {peak_hour}시 ({hourly_signups[peak_hour]}명)")
            
            return {
                'valid': True,
                'start_date': start_date.strftime('%Y-%m-%d'),
                'end_date': end_date.strftime('%Y-%m-%d'),
                'start_datetime': start_date,
                'end_datetime': end_date,
                'total_days': total_days,
                'total_users': len(create_times),
                'avg_daily_signups': avg_daily_signups,
                'valid_ratio': 100.0,  # 빈 값이 없다고 했으므로 항상 100%
                'daily_signups': daily_signups,
                'hourly_signups': hourly_signups,
                'weekday_signups': weekday_signups,
                'peak_hour': peak_hour,
                'peak_hour_count': hourly_signups[peak_hour],
                'weekday_names': weekday_names
            }
            
        except Exception as e:
            self.log_message("PERIOD", f"분석 기간 추출 중 오류: {str(e)}", "ERROR")
            # ISO 형식 파싱 실패 시 일반적인 방법으로 재시도
            try:
                create_times = pd.to_datetime(self.df['create_time'], errors='coerce')
                valid_times = create_times.dropna()
                
                if len(valid_times) == 0:
                    return {'valid': False}
                
                start_date = valid_times.min()
                end_date = valid_times.max()
                total_days = (end_date - start_date).days + 1
                daily_signups = valid_times.dt.date.value_counts().sort_index()
                avg_daily_signups = len(valid_times) / total_days if total_days > 0 else 0
                
                return {
                    'valid': True,
                    'start_date': start_date.strftime('%Y-%m-%d'),
                    'end_date': end_date.strftime('%Y-%m-%d'),
                    'start_datetime': start_date,
                    'end_datetime': end_date,
                    'total_days': total_days,
                    'total_users': len(valid_times),
                    'avg_daily_signups': avg_daily_signups,
                    'valid_ratio': len(valid_times) / len(self.df) * 100,
                    'daily_signups': daily_signups
                }
            except:
                return {'valid': False}
    
    def analyze_correlations(self):
        """모든 지표와 retention_status 간의 상관관계 분석"""
        self.log_message("CORRELATION", "상관관계 분석 시작")
        
        # 분석할 컬럼 선택
        exclude_cols = self.config['exclude_columns']
        all_numeric_cols = self.df.select_dtypes(include=[np.number]).columns.tolist()
        numeric_cols = [col for col in all_numeric_cols if col not in exclude_cols]
        
        self.log_message("CORRELATION", f"분석 대상 지표: {len(numeric_cols)}개")
        
        correlations = []
        
        # 진행률 바와 함께 상관관계 분석
        for col in tqdm(numeric_cols, desc="상관관계 분석 중"):
            try:
                # NULL 값 제거
                valid_data = self.df[[col, 'retention_encoded']].dropna()
                
                if len(valid_data) < self.config['analysis_settings']['min_sample_size']:
                    continue
                
                # Spearman 상관계수 계산
                corr, p_value = spearmanr(valid_data[col], valid_data['retention_encoded'])
                
                correlations.append({
                    'metric': col,
                    'correlation': corr,
                    'p_value': p_value,
                    'significant': p_value < self.config['analysis_settings']['correlation_threshold'],
                    'abs_correlation': abs(corr)
                })
                
            except Exception as e:
                self.log_message("CORRELATION", f"Warning: {col} 분석 실패 - {str(e)}", "WARNING")
                continue
        
        # 결과 정리
        self.correlation_results = pd.DataFrame(correlations)
        self.correlation_results = self.correlation_results.sort_values('abs_correlation', ascending=False)
        
        # 상위 결과 출력
        self.log_message("CORRELATION", "")
        self.log_message("CORRELATION", "[+] Retention에 긍정적 영향 (Top 15):")
        
        positive = self.correlation_results[
            (self.correlation_results['correlation'] > 0) & 
            (self.correlation_results['significant'])
        ].head(15)
        
        for _, row in positive.iterrows():
            self.log_message("CORRELATION", f"  {row['metric']}: {row['correlation']:.3f}")
        
        self.log_message("CORRELATION", "")
        self.log_message("CORRELATION", "[-] Retention에 부정적 영향 (Top 15):")
        
        negative = self.correlation_results[
            (self.correlation_results['correlation'] < 0) & 
            (self.correlation_results['significant'])
        ].head(15)
        
        for _, row in negative.iterrows():
            self.log_message("CORRELATION", f"  {row['metric']}: {row['correlation']:.3f}")
        
        # 결과 저장
        if self.config['output_settings']['save_csv']:
            output_file = f"{self.output_dir}/correlation_analysis_{self.timestamp}.csv"
            self.correlation_results.to_csv(output_file, index=False)
            self.log_message("CORRELATION", f"결과 저장: {output_file}")
        
        return self.correlation_results
    
    def analyze_d0_churners(self):
        """D0 이탈 유저 특성 분석"""
        self.log_message("D0_ANALYSIS", "D0 이탈 유저 특성 분석 시작")
        
        d0_users = self.df[self.df['retention_status'] == 'Retained_d0']
        retained_users = self.df[self.df['retention_status'] != 'Retained_d0']
        
        self.log_message("D0_ANALYSIS", f"D0 이탈 유저: {len(d0_users):,}명")
        self.log_message("D0_ANALYSIS", f"잔존 유저: {len(retained_users):,}명")
        
        # 주요 지표 비교
        key_metrics = self.config['key_metrics_for_d0_analysis']
        comparison = []
        
        self.log_message("D0_ANALYSIS", "")
        self.log_message("D0_ANALYSIS", "=== D0 이탈 vs 잔존 유저 주요 차이 ===")
        
        for metric in tqdm(key_metrics, desc="D0 분석 중"):
            if metric in self.df.columns:
                try:
                    d0_data = d0_users[metric].dropna()
                    retained_data = retained_users[metric].dropna()
                    
                    if len(d0_data) < 10 or len(retained_data) < 10:
                        continue
                        
                    d0_mean = d0_data.mean()
                    retained_mean = retained_data.mean()
                    
                    # t-test
                    t_stat, p_value = stats.ttest_ind(d0_data, retained_data, equal_var=False)
                    
                    diff_pct = ((retained_mean - d0_mean) / (d0_mean + 0.0001)) * 100
                    
                    comparison.append({
                        'metric': metric,
                        'd0_mean': d0_mean,
                        'retained_mean': retained_mean,
                        'difference_%': diff_pct,
                        'p_value': p_value,
                        'significant': p_value < 0.05
                    })
                    
                except Exception as e:
                    self.log_message("D0_ANALYSIS", f"Warning: {metric} 분석 실패 - {str(e)}", "WARNING")
                    continue
        
        comparison_df = pd.DataFrame(comparison)
        comparison_df = comparison_df.sort_values('difference_%', ascending=False)
        
        # 클래스 변수로 저장 (HTML 리포트에서 사용)
        self.d0_comparison = comparison_df
        
        # 결과 출력
        for _, row in comparison_df.head(10).iterrows():
            if row['significant']:
                self.log_message("D0_ANALYSIS", f"  {row['metric']}:")
                self.log_message("D0_ANALYSIS", f"    D0 평균: {row['d0_mean']:.2f}")
                self.log_message("D0_ANALYSIS", f"    잔존 평균: {row['retained_mean']:.2f}")
                self.log_message("D0_ANALYSIS", f"    차이: {row['difference_%']:.1f}%")
        
        # 결과 저장
        if self.config['output_settings']['save_csv']:
            output_file = f"{self.output_dir}/d0_churn_analysis_{self.timestamp}.csv"
            comparison_df.to_csv(output_file, index=False)
            self.log_message("D0_ANALYSIS", f"결과 저장: {output_file}")
        
        return comparison_df
    
    def feature_importance_analysis(self):
        """Random Forest를 이용한 Feature Importance 분석"""
        self.log_message("FEATURE_IMPORTANCE", "Feature Importance 분석 시작")
        
        # 데이터 준비
        exclude_cols = self.config['exclude_columns']
        numeric_cols = self.df.select_dtypes(include=[np.number]).columns.tolist()
        feature_cols = [col for col in numeric_cols if col not in exclude_cols]
        
        X = self.df[feature_cols].fillna(0)
        y = self.df['retention_encoded']
        
        self.log_message("FEATURE_IMPORTANCE", f"Feature 수: {len(feature_cols)}")
        self.log_message("FEATURE_IMPORTANCE", f"샘플 수: {len(X)}")
        
        # Random Forest 모델 학습 (진행률 표시)
        with tqdm(desc="Random Forest 학습 중") as pbar:
            rf = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1)
            rf.fit(X, y)
            pbar.update(1)
        
        # Feature Importance 추출
        importance_df = pd.DataFrame({
            'feature': feature_cols,
            'importance': rf.feature_importances_
        }).sort_values('importance', ascending=False)
        
        self.log_message("FEATURE_IMPORTANCE", "")
        self.log_message("FEATURE_IMPORTANCE", f"=== Top {self.config['analysis_settings']['top_n_features']} 중요 지표 ===")
        
        top_n = self.config['analysis_settings']['top_n_features']
        for idx, row in importance_df.head(top_n).iterrows():
            self.log_message("FEATURE_IMPORTANCE", f"  {row['feature']}: {row['importance']:.4f}")
        
        # 결과 저장
        if self.config['output_settings']['save_csv']:
            output_file = f"{self.output_dir}/feature_importance_{self.timestamp}.csv"
            importance_df.to_csv(output_file, index=False)
            self.log_message("FEATURE_IMPORTANCE", f"결과 저장: {output_file}")
        
        self.feature_importance = importance_df
        return importance_df
    
    def generate_insights_report(self):
        """HTML 형식의 종합 인사이트 리포트 생성"""
        self.log_message("REPORT", "HTML 인사이트 리포트 생성 시작")
        
        # 기본 통계 계산
        d0_rate = len(self.df[self.df['retention_status'] == 'Retained_d0']) / len(self.df) * 100
        d1_rate = len(self.df[self.df['retention_status'] == 'Retained_d1']) / len(self.df) * 100
        d2_rate = len(self.df[self.df['retention_status'] == 'Retained_d2']) / len(self.df) * 100
        d3_rate = len(self.df[self.df['retention_status'] == 'Retained_d3']) / len(self.df) * 100
        d3_plus_rate = len(self.df[self.df['retention_encoded'] >= 3]) / len(self.df) * 100
        d7_plus_rate = len(self.df[self.df['retention_status'] == 'Retained_d7+']) / len(self.df) * 100
        
        # 리텐션 분포 데이터
        retention_dist = self.df['retention_status'].value_counts().sort_index()
        
        # 상관관계 분석 결과 준비 (HTML 전체에서 사용하기 위해 미리 준비)
        positive = pd.DataFrame()  # 기본값
        negative = pd.DataFrame()  # 기본값
        
        if not self.correlation_results.empty:
            positive = self.correlation_results[
                (self.correlation_results['correlation'] > 0) & 
                (self.correlation_results['significant'])
            ].head(15)
            
            negative = self.correlation_results[
                (self.correlation_results['correlation'] < 0) & 
                (self.correlation_results['significant'])
            ].head(15)
        
        # HTML 생성
        html_content = f"""
<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>던전 스토커즈 - 신규 유저 리텐션 분석 리포트</title>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        body {{ 
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; 
            line-height: 1.6; 
            color: #333; 
            background: #f5f7fa;
            padding: 20px;
        }}
        .container {{ 
            max-width: 1400px; 
            margin: 0 auto; 
            background: white; 
            border-radius: 12px; 
            box-shadow: 0 4px 20px rgba(0,0,0,0.1);
            overflow: hidden;
        }}
        .header {{ 
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
            color: white; 
            padding: 30px; 
            text-align: center; 
        }}
        .header h1 {{ font-size: 2.5em; margin-bottom: 10px; font-weight: 300; }}
        .header p {{ font-size: 1.2em; opacity: 0.9; }}
        .content {{ padding: 40px; }}
        .section {{ margin-bottom: 40px; }}
        .section h2 {{ 
            color: #2c3e50; 
            border-bottom: 3px solid #3498db; 
            padding-bottom: 10px; 
            margin-bottom: 20px; 
            font-size: 1.8em;
        }}
        .section h3 {{ 
            color: #34495e; 
            margin-bottom: 15px; 
            font-size: 1.4em;
            background: #ecf0f1;
            padding: 10px 15px;
            border-radius: 8px;
        }}
        .stats-grid {{ 
            display: grid; 
            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); 
            gap: 20px; 
            margin-bottom: 30px; 
        }}
        .stat-card {{ 
            background: white; 
            border-radius: 10px; 
            padding: 25px; 
            text-align: center; 
            box-shadow: 0 4px 15px rgba(0,0,0,0.05);
            border: 2px solid #ecf0f1;
            transition: transform 0.3s ease;
        }}
        .stat-card:hover {{ transform: translateY(-5px); }}
        .stat-value {{ 
            font-size: 2.5em; 
            font-weight: bold; 
            margin-bottom: 10px; 
        }}
        .stat-label {{ 
            color: #7f8c8d; 
            font-size: 1.1em; 
            text-transform: uppercase; 
            letter-spacing: 1px; 
        }}
        .critical {{ color: #e74c3c; }}
        .good {{ color: #27ae60; }}
        .warning {{ color: #f39c12; }}
        .table {{ 
            width: 100%; 
            border-collapse: collapse; 
            margin-top: 20px; 
            background: white;
            border-radius: 8px;
            overflow: hidden;
            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
        }}
        .table th {{ 
            background: #34495e; 
            color: white; 
            padding: 15px; 
            text-align: left; 
            font-weight: 600;
        }}
        .table td {{ 
            padding: 12px 15px; 
            border-bottom: 1px solid #ecf0f1; 
        }}
        .table tr:hover {{ background: #f8f9fa; }}
        .table tr:nth-child(even) {{ background: #fafbfc; }}
        .positive {{ color: #27ae60; font-weight: bold; }}
        .negative {{ color: #e74c3c; font-weight: bold; }}
        .metric-name {{ 
            font-weight: bold; 
            color: #2c3e50; 
            font-family: 'Courier New', monospace;
            background: #ecf0f1;
            padding: 2px 6px;
            border-radius: 4px;
        }}
        .correlation-value {{ font-size: 1.1em; font-weight: bold; }}
        .p-value {{ color: #7f8c8d; font-size: 0.9em; }}
        .retention-distribution {{ 
            display: grid; 
            grid-template-columns: repeat(auto-fit, minmax(120px, 1fr)); 
            gap: 15px; 
            margin: 20px 0; 
        }}
        .retention-item {{ 
            text-align: center; 
            padding: 15px; 
            background: white; 
            border-radius: 8px; 
            box-shadow: 0 2px 8px rgba(0,0,0,0.05);
            border: 2px solid #ecf0f1;
        }}
        .retention-label {{ 
            font-size: 0.9em; 
            color: #7f8c8d; 
            margin-bottom: 5px; 
        }}
        .retention-count {{ 
            font-size: 1.4em; 
            font-weight: bold; 
            color: #2c3e50; 
        }}
        .retention-percent {{ 
            font-size: 0.9em; 
            color: #3498db; 
            font-weight: bold; 
        }}
        .info-box {{ 
            background: #e8f6f3; 
            border-left: 5px solid #1abc9c; 
            padding: 20px; 
            margin: 20px 0; 
            border-radius: 5px; 
        }}
        .warning-box {{ 
            background: #fdf2e9; 
            border-left: 5px solid #e67e22; 
            padding: 20px; 
            margin: 20px 0; 
            border-radius: 5px; 
        }}
        .critical-box {{ 
            background: #fadbd8; 
            border-left: 5px solid #e74c3c; 
            padding: 20px; 
            margin: 20px 0; 
            border-radius: 5px; 
        }}
        .footer {{ 
            background: #34495e; 
            color: white; 
            padding: 20px; 
            text-align: center; 
        }}
        .analysis-timestamp {{ color: #95a5a6; }}
        ul {{ margin-left: 20px; }}
        li {{ margin-bottom: 8px; }}
    </style>
</head>
<body>
    <div class="container">
        <header class="header">
            <h1>던전 스토커즈</h1>
            <p>신규 유저 리텐션 분석 리포트</p>
            <div class="analysis-timestamp">분석 일시: {datetime.now().strftime('%Y년 %m월 %d일 %H:%M:%S')}</div>
        </header>

        <div class="content">
            <!-- 실행 정보 -->
            <section class="section">
                <h2>📊 분석 개요</h2>
                <div class="info-box">
                    <strong>데이터 파일:</strong> {os.path.basename(self.csv_path)}<br>
                    <strong>분석 대상:</strong> {len(self.df):,}명의 신규 유저<br>"""
        
        # 분석 기간 정보 추가
        if hasattr(self, 'analysis_period_info') and self.analysis_period_info['valid']:
            period_info = self.analysis_period_info
            html_content += f"""
                    <strong>분석 기간:</strong> {period_info['start_date']} ~ {period_info['end_date']} ({period_info['total_days']}일)<br>
                    <strong>일평균 신규 가입:</strong> {period_info['avg_daily_signups']:.1f}명<br>
                    <strong>데이터 품질:</strong> {period_info['valid_ratio']:.1f}% (유효한 가입일 데이터)<br>"""
        
        html_content += f"""
                    <strong>분석 범위:</strong> D0 ~ D7+ 리텐션 분석<br>
                    <strong>통계 방법:</strong> Spearman 상관분석, Welch's t-test, Random Forest 특성 중요도
                </div>"""
        
        # 분석 기간 상세 정보 (별도 섹션)
        if hasattr(self, 'analysis_period_info') and self.analysis_period_info['valid']:
            period_info = self.analysis_period_info
            
            # 최근 7일, 최근 30일 가입자 수 계산 (가능한 경우)
            recent_stats = ""
            try:
                end_datetime = period_info['end_datetime']
                recent_7days = len(self.df[pd.to_datetime(self.df['create_time'], errors='coerce') >= (end_datetime - pd.Timedelta(days=7))])
                recent_30days = len(self.df[pd.to_datetime(self.df['create_time'], errors='coerce') >= (end_datetime - pd.Timedelta(days=30))])
                
                recent_stats = f"""
                <div class="stats-grid">
                    <div class="stat-card">
                        <div class="stat-value good">{recent_7days:,}</div>
                        <div class="stat-label">최근 7일 가입</div>
                    </div>
                    <div class="stat-card">
                        <div class="stat-value good">{recent_30days:,}</div>
                        <div class="stat-label">최근 30일 가입</div>
                    </div>
                    <div class="stat-card">
                        <div class="stat-value warning">{period_info['total_days']}</div>
                        <div class="stat-label">전체 분석 일수</div>
                    </div>
                    <div class="stat-card">
                        <div class="stat-value good">{period_info['avg_daily_signups']:.1f}</div>
                        <div class="stat-label">일평균 신규가입</div>
                    </div>
                </div>"""
            except:
                pass
            
            # 시간대/요일별 패턴 정보 추가
            pattern_info = ""
            if 'peak_hour' in period_info and 'weekday_signups' in period_info:
                # 가장 활발한 요일 찾기
                max_weekday_idx = period_info['weekday_signups'].idxmax()
                max_weekday_name = period_info['weekday_names'][max_weekday_idx]
                max_weekday_count = period_info['weekday_signups'][max_weekday_idx]
                
                pattern_info = f"""
                <div class="info-box">
                    <h4>🕒 가입 패턴 분석</h4>
                    <strong>가입 집중 시간대:</strong> {period_info['peak_hour']}시 ({period_info['peak_hour_count']:,}명)<br>
                    <strong>가입 집중 요일:</strong> {max_weekday_name}요일 ({max_weekday_count:,}명)<br>
                    <strong>시간대 분석:</strong> 한국 시간(KST) 기준으로 분석됨
                </div>"""
            
            html_content += f"""
                
                <h3>📅 분석 기간 상세</h3>
                <div class="warning-box">
                    <strong>데이터 수집 기간:</strong> {period_info['start_date']} ~ {period_info['end_date']}<br>
                    <strong>전체 분석 대상:</strong> {period_info['total_users']:,}명 (ISO 8601 표준 형식)<br>
                    <strong>일평균 신규 가입자:</strong> {period_info['avg_daily_signups']:.1f}명<br>
                    <strong>분석 대상 기간:</strong> {period_info['total_days']}일간의 신규 가입자 행동 패턴<br>
                    <strong>데이터 품질:</strong> {period_info['valid_ratio']:.1f}% (표준 시간 형식으로 완전한 데이터)
                </div>
                {pattern_info}
                {recent_stats}"""
        
        html_content += f"""
            </section>

            <!-- 전체 리텐션 현황 -->
            <section class="section">
                <h2>🎯 전체 리텐션 현황</h2>
                <div class="stats-grid">
                    <div class="stat-card">
                        <div class="stat-value critical">{d0_rate:.1f}%</div>
                        <div class="stat-label">D0 이탈률</div>
                    </div>
                    <div class="stat-card">
                        <div class="stat-value warning">{d1_rate:.1f}%</div>
                        <div class="stat-label">D1 유지율</div>
                    </div>
                    <div class="stat-card">
                        <div class="stat-value good">{d3_plus_rate:.1f}%</div>
                        <div class="stat-label">D3+ 잔존율</div>
                    </div>
                    <div class="stat-card">
                        <div class="stat-value good">{d7_plus_rate:.1f}%</div>
                        <div class="stat-label">D7+ 잔존율</div>
                    </div>
                </div>

                <div class="critical-box">
                    <h3>⚠️ Critical Alert</h3>
                    <p><strong>D0 이탈률 {d0_rate:.1f}%</strong>는 게임 업계 평균(25-35%)을 크게 상회하는 매우 심각한 수준입니다.</p>
                    <p>즉시 개선 조치가 필요합니다.</p>
                </div>

                <h3>일별 리텐션 분포</h3>
                <div class="retention-distribution">"""
                
        # 리텐션 분포 HTML 생성
        for status in self.config['retention_groups']:
            if status in retention_dist.index:
                count = retention_dist[status]
                pct = count / len(self.df) * 100
                html_content += f"""
                    <div class="retention-item">
                        <div class="retention-label">{status.replace('Retained_', '')}</div>
                        <div class="retention-count">{count:,}</div>
                        <div class="retention-percent">{pct:.1f}%</div>
                    </div>"""
        
        html_content += """
                </div>
            </section>"""

        # 상관관계 분석 결과
        if not self.correlation_results.empty:
            html_content += f"""
            <!-- 상관관계 분석 -->
            <section class="section">
                <h2>🔍 리텐션 영향 요인 분석</h2>
                
                <div class="info-box">
                    <strong>분석 방법:</strong> Spearman 순위 상관계수 (ρ)<br>
                    <strong>유의수준:</strong> p < 0.05<br>
                    <strong>분석 지표 수:</strong> {len(self.correlation_results)}개<br>
                    <strong>유의한 지표 수:</strong> {len(self.correlation_results[self.correlation_results['significant']])}개
                </div>

                <h3>📈 리텐션 향상 요인 (긍정적 상관관계)</h3>
                <table class="table">
                    <thead>
                        <tr>
                            <th>순위</th>
                            <th>지표명</th>
                            <th>상관계수 (ρ)</th>
                            <th>유의확률 (p)</th>
                            <th>해석</th>
                        </tr>
                    </thead>
                    <tbody>"""
            
            for idx, (_, row) in enumerate(positive.iterrows(), 1):
                interpretation = "강한 긍정적 관계" if row['correlation'] > 0.3 else "중간 긍정적 관계" if row['correlation'] > 0.1 else "약한 긍정적 관계"
                html_content += f"""
                        <tr>
                            <td><strong>{idx}</strong></td>
                            <td><span class="metric-name">{row['metric']}</span></td>
                            <td><span class="correlation-value positive">+{row['correlation']:.3f}</span></td>
                            <td><span class="p-value">{'< 0.001' if row['p_value'] < 0.001 else f'{row["p_value"]:.3f}'}</span></td>
                            <td>{interpretation}</td>
                        </tr>"""
            
            html_content += """
                    </tbody>
                </table>"""

            if len(negative) > 0:
                html_content += """
                <h3>📉 리텐션 저해 요인 (부정적 상관관계)</h3>
                <table class="table">
                    <thead>
                        <tr>
                            <th>순위</th>
                            <th>지표명</th>
                            <th>상관계수 (ρ)</th>
                            <th>유의확률 (p)</th>
                            <th>해석</th>
                        </tr>
                    </thead>
                    <tbody>"""
                
                for idx, (_, row) in enumerate(negative.iterrows(), 1):
                    interpretation = "강한 부정적 관계" if abs(row['correlation']) > 0.3 else "중간 부정적 관계" if abs(row['correlation']) > 0.1 else "약한 부정적 관계"
                    html_content += f"""
                            <tr>
                                <td><strong>{idx}</strong></td>
                                <td><span class="metric-name">{row['metric']}</span></td>
                                <td><span class="correlation-value negative">{row['correlation']:.3f}</span></td>
                                <td><span class="p-value">{'< 0.001' if row['p_value'] < 0.001 else f'{row["p_value"]:.3f}'}</span></td>
                                <td>{interpretation}</td>
                            </tr>"""
                
                html_content += """
                        </tbody>
                    </table>"""

            html_content += """
            </section>"""

        # D0 분석 결과가 있다면 추가
        if hasattr(self, 'd0_comparison') and not self.d0_comparison.empty:
            html_content += f"""
            <!-- D0 이탈 분석 -->
            <section class="section">
                <h2>🎯 D0 이탈 vs 잔존 유저 비교 분석</h2>
                
                <div class="warning-box">
                    <strong>분석 대상:</strong><br>
                    D0 이탈 유저: {len(self.df[self.df['retention_status'] == 'Retained_d0']):,}명<br>
                    잔존 유저: {len(self.df[self.df['retention_status'] != 'Retained_d0']):,}명
                </div>

                <h3>핵심 지표별 차이 분석</h3>
                <table class="table">
                    <thead>
                        <tr>
                            <th>지표명</th>
                            <th>D0 이탈자 평균</th>
                            <th>잔존자 평균</th>
                            <th>차이율</th>
                            <th>유의확률 (p)</th>
                            <th>해석</th>
                        </tr>
                    </thead>
                    <tbody>"""
            
            significant_diffs = self.d0_comparison[self.d0_comparison['significant']].head(15)
            for _, row in significant_diffs.iterrows():
                if row['difference_%'] > 100:
                    interpretation = "매우 큰 차이 (즉시 개선 필요)"
                elif row['difference_%'] > 50:
                    interpretation = "큰 차이 (우선 개선)"
                elif row['difference_%'] > 20:
                    interpretation = "중간 차이 (개선 고려)"
                else:
                    interpretation = "작은 차이"
                    
                diff_class = "positive" if row['difference_%'] > 0 else "negative"
                    
                html_content += f"""
                        <tr>
                            <td><span class="metric-name">{row['metric']}</span></td>
                            <td>{row['d0_mean']:.2f}</td>
                            <td>{row['retained_mean']:.2f}</td>
                            <td><span class="correlation-value {diff_class}">{row['difference_%']:+.1f}%</span></td>
                            <td><span class="p-value">{'< 0.001' if row['p_value'] < 0.001 else f'{row["p_value"]:.3f}'}</span></td>
                            <td>{interpretation}</td>
                        </tr>"""
            
            html_content += """
                    </tbody>
                </table>
            </section>"""

        # Feature Importance 결과
        if hasattr(self, 'feature_importance') and not self.feature_importance.empty:
            top_features = self.feature_importance.head(20)
            html_content += f"""
            <!-- Feature Importance -->
            <section class="section">
                <h2>🎖️ 리텐션 예측 중요도 분석</h2>
                
                <div class="info-box">
                    <strong>분석 방법:</strong> Random Forest Classifier<br>
                    <strong>모델 설정:</strong> 100개 트리, 교차 검증<br>
                    <strong>분석 특성 수:</strong> {len(self.feature_importance)}개
                </div>

                <h3>Top 20 중요 특성</h3>
                <table class="table">
                    <thead>
                        <tr>
                            <th>순위</th>
                            <th>지표명</th>
                            <th>중요도 점수</th>
                            <th>중요도 등급</th>
                            <th>액션 우선순위</th>
                        </tr>
                    </thead>
                    <tbody>"""
            
            for idx, (_, row) in enumerate(top_features.iterrows(), 1):
                importance = row['importance']
                if importance >= 0.1:
                    grade = "매우 높음"
                    priority = "즉시 액션"
                    grade_class = "critical"
                elif importance >= 0.05:
                    grade = "높음"
                    priority = "우선 개선"
                    grade_class = "warning"
                elif importance >= 0.01:
                    grade = "보통"
                    priority = "모니터링"
                    grade_class = "good"
                else:
                    grade = "낮음"
                    priority = "후순위"
                    grade_class = ""
                
                html_content += f"""
                        <tr>
                            <td><strong>{idx}</strong></td>
                            <td><span class="metric-name">{row['feature']}</span></td>
                            <td><span class="correlation-value">{importance:.4f}</span></td>
                            <td><span class="{grade_class}">{grade}</span></td>
                            <td>{priority}</td>
                        </tr>"""
            
            html_content += """
                    </tbody>
                </table>
            </section>"""

        # 개선 권고사항
        html_content += f"""
        <!-- 개선 권고사항 -->
        <section class="section">
            <h2>🚀 개선 권고사항</h2>
            
            <div class="critical-box">
                <h3>🔥 즉시 실행 (Critical)</h3>
                <ul>
                    <li><strong>D0 이탈률 {d0_rate:.1f}%</strong> - 업계 평균의 2배 수준으로 즉시 개선 필요</li>"""
        
        if not self.correlation_results.empty and len(positive) > 0:
            top_positive = positive.iloc[0]
            html_content += f"""
                    <li><strong>{top_positive['metric']}</strong> 지표 강화 - 최고 긍정 요인 (상관계수: {top_positive['correlation']:.3f})</li>"""
        
        html_content += """
                    <li>신규 유저 온보딩 프로세스 전면 재검토</li>
                    <li>첫날 경험 최적화 프로젝트 착수</li>
                </ul>
            </div>
            
            <div class="warning-box">
                <h3>⚡ 우선 개선 (High Priority)</h3>
                <ul>"""
        
        if not self.correlation_results.empty:
            for _, row in positive.head(3).iterrows():
                html_content += f"""
                    <li><span class="metric-name">{row['metric']}</span> 개선 - 리텐션 향상 효과 기대 (ρ = {row['correlation']:.3f})</li>"""
        
        html_content += """
                    <li>D1-D3 전환율 개선 프로그램 도입</li>
                    <li>이탈 위험 유저 조기 탐지 시스템 구축</li>
                </ul>
            </div>
            
            <div class="info-box">
                <h3>📊 지속 모니터링 (Monitoring)</h3>
                <ul>"""
                    
        if len(negative) > 0:
            for _, row in negative.head(3).iterrows():
                html_content += f"""
                    <li><span class="metric-name">{row['metric']}</span> 모니터링 - 부정적 영향 최소화 (ρ = {row['correlation']:.3f})</li>"""
        
        html_content += f"""
                    <li>주간 리텐션 대시보드 구축</li>
                    <li>A/B 테스트를 통한 개선 효과 검증</li>
                    <li>세그먼트별 리텐션 패턴 심층 분석</li>
                </ul>
            </div>
        </section>

        <!-- 종합 결론 -->
        <section class="section">
            <h2>📝 종합 결론</h2>
            
            <div class="critical-box">
                <h3>현재 상황 진단</h3>
                <p>던전 스토커즈의 <strong>D0 이탈률 {d0_rate:.1f}%</strong>는 게임 업계 평균(25-35%)을 크게 상회하는 
                <strong>Critical 수준</strong>입니다. 이는 서비스 지속성에 직접적인 위협이 되는 상황으로, 
                즉시 종합적인 개선 조치가 필요합니다.</p>
            </div>
            
            <div class="info-box">
                <h3>핵심 개선 전략</h3>
                <ol>
                    <li><strong>첫날 경험 최적화</strong>: 온보딩, 튜토리얼, 초기 보상 시스템 전면 재설계</li>
                    <li><strong>데이터 기반 개선</strong>: 긍정적 상관관계 지표들의 초기 경험 강화</li>
                    <li><strong>위험 요소 제거</strong>: 부정적 영향 지표들의 영향도 최소화</li>
                    <li><strong>지속적 모니터링</strong>: 실시간 리텐션 추적 및 조기 경보 시스템</li>
                </ol>
            </div>
            
            <div class="warning-box">
                <h3>기대 효과</h3>
                <p>본 분석 결과를 바탕으로 한 개선 조치 시행 시, <strong>D0 이탈률을 업계 평균 수준인 30% 이하로 
                개선</strong>할 수 있을 것으로 예상됩니다. 이는 <strong>월간 신규 유저 중 약 35% 추가 확보</strong>를 
                의미하며, 장기적으로 서비스 성장에 크게 기여할 것입니다.</p>
            </div>
        </section>
        </div>

        <footer class="footer">
            <p>던전 스토커즈 리텐션 분석 리포트 | 생성일시: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
            <p>데이터 기반 의사결정으로 더 나은 게임 경험을 만들어가겠습니다.</p>
        </footer>
    </div>
</body>
</html>"""

        # HTML 리포트 저장
        output_file = f"{self.output_dir}/insights_report_{self.timestamp}.html"
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write(html_content)
        self.log_message("REPORT", f"HTML 리포트 저장: {output_file}")
        
        # 콘솔에 요약만 출력
        self.log_message("REPORT", "")
        self.log_message("REPORT", "="*60)
        self.log_message("REPORT", "RETENTION 분석 완료 - 주요 결과")
        self.log_message("REPORT", "="*60)
        self.log_message("REPORT", f"D0 이탈률: {d0_rate:.1f}% (매우 심각)")
        self.log_message("REPORT", f"D7+ 잔존률: {d7_plus_rate:.1f}%")
        
        if not self.correlation_results.empty:
            positive = self.correlation_results[
                (self.correlation_results['correlation'] > 0) & 
                (self.correlation_results['significant'])
            ].head(1)
            if len(positive) > 0:
                top_positive = positive.iloc[0]
                self.log_message("REPORT", f"최고 긍정 지표: {top_positive['metric']} ({top_positive['correlation']:.3f})")
        
        self.log_message("REPORT", "="*60)
        
        return html_content
    
    def run_full_analysis(self):
        """전체 분석 실행"""
        self.log_message("MAIN", "Retention 분석 시작")
        
        try:
            # 1. CSV 유효성 검사
            self.validate_csv()
            
            # 2. 데이터 로드
            self.load_data()
            
            # 3. 상관관계 분석
            self.analyze_correlations()
            
            # 4. D0 이탈 분석  
            self.analyze_d0_churners()
            
            # 5. Feature Importance
            self.feature_importance_analysis()
            
            # 6. 인사이트 리포트
            self.generate_insights_report()
            
            self.log_message("MAIN", "")
            self.log_message("MAIN", "SUCCESS: 모든 분석 완료!")
            self.log_message("MAIN", f"결과 파일들이 {self.output_dir}/ 디렉토리에 저장되었습니다.")
            
        except Exception as e:
            self.log_message("MAIN", f"분석 중 오류 발생: {str(e)}", "ERROR")
            raise


def get_csv_path():
    """사용자로부터 CSV 파일 경로 입력받기"""
    if len(sys.argv) > 1:
        return sys.argv[1]
    
    print("="*60)
    print("Retention Analysis Tool")  
    print("="*60)
    print()
    
    while True:
        csv_path = input(">> 분석할 CSV 파일 경로를 입력하세요: ").strip()
        
        if not csv_path:
            print("ERROR: 경로를 입력해주세요.")
            continue
            
        # 따옴표 제거
        csv_path = csv_path.strip('"\'')
        
        if not os.path.exists(csv_path):
            print(f"ERROR: 파일을 찾을 수 없습니다: {csv_path}")
            continue
            
        if not csv_path.lower().endswith('.csv'):
            print("ERROR: CSV 파일만 지원됩니다.")
            continue
            
        return csv_path


def main():
    """메인 실행 함수"""
    try:
        csv_path = get_csv_path()
        
        print(f"\n=== 분석 시작: {os.path.basename(csv_path)} ===")
        print("="*60)
        
        analyzer = RetentionAnalyzer(csv_path)
        analyzer.run_full_analysis()
        
    except KeyboardInterrupt:
        print("\n\nWARNING: 사용자에 의해 중단되었습니다.")
    except Exception as e:
        print(f"\n\nERROR: 오류 발생: {str(e)}")
        sys.exit(1)


if __name__ == "__main__":
    main()