"""
i2i - DeepWalk算法实现
基于用户-物品图结构训练DeepWalk模型，获取物品向量相似度
复用 graphembedding/deepwalk/ 的高效实现
"""
import pandas as pd
import argparse
import os
import sys
from datetime import datetime
from collections import defaultdict
from gensim.models import Word2Vec
from db_service import create_db_connection
from config import (
    DB_CONFIG, OUTPUT_DIR, I2I_CONFIG, get_time_range,
    DEFAULT_LOOKBACK_DAYS, DEFAULT_I2I_TOP_N
)
from debug_utils import (
    setup_debug_logger, log_dataframe_info,
    save_readable_index, fetch_name_mappings, log_algorithm_params,
    log_processing_step
)

# 导入 DeepWalk 实现
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)), 'deepwalk'))
from deepwalk import DeepWalk


def build_edge_file_from_db(df, behavior_weights, output_path, logger):
    """
    从数据库数据构建边文件
    边文件格式: item_id \t neighbor_id1:weight1,neighbor_id2:weight2,...
    
    Args:
        df: DataFrame with columns: user_id, item_id, event_type
        behavior_weights: 行为权重字典
        output_path: 边文件输出路径
        logger: 日志对象
    """
    logger.info("开始构建物品图...")
    
    # 构建用户-物品列表
    user_items = defaultdict(list)
    
    for _, row in df.iterrows():
        user_id = row['user_id']
        item_id = str(row['item_id'])
        event_type = row['event_type']
        weight = behavior_weights.get(event_type, 1.0)
        user_items[user_id].append((item_id, weight))
    
    logger.info(f"共有 {len(user_items)} 个用户")
    
    # 构建物品图边
    edge_dict = defaultdict(lambda: defaultdict(float))
    
    for user_id, items in user_items.items():
        # 限制每个用户的物品数量，避免内存爆炸
        if len(items) > 100:
            # 按权重排序，只保留前100个
            items = sorted(items, key=lambda x: -x[1])[:100]
        
        # 物品两两组合，构建边
        for i in range(len(items)):
            item_i, weight_i = items[i]
            for j in range(i + 1, len(items)):
                item_j, weight_j = items[j]
                
                # 边的权重为两个物品权重的平均值
                edge_weight = (weight_i + weight_j) / 2.0
                edge_dict[item_i][item_j] += edge_weight
                edge_dict[item_j][item_i] += edge_weight
    
    logger.info(f"构建物品图完成，共 {len(edge_dict)} 个节点")
    
    # 保存边文件
    logger.info(f"保存边文件到 {output_path}")
    with open(output_path, 'w', encoding='utf-8') as f:
        for item_id, neighbors in edge_dict.items():
            neighbor_str = ','.join([f'{nbr}:{weight:.4f}' for nbr, weight in neighbors.items()])
            f.write(f'{item_id}\t{neighbor_str}\n')
    
    logger.info(f"边文件保存完成")
    return len(edge_dict)


def train_word2vec_from_walks(walks_file, config, logger):
    """
    从游走文件训练Word2Vec模型
    
    Args:
        walks_file: 游走序列文件路径
        config: Word2Vec配置
        logger: 日志对象
    
    Returns:
        Word2Vec模型
    """
    logger.info(f"从 {walks_file} 读取游走序列...")
    
    # 读取游走序列
    sentences = []
    with open(walks_file, 'r', encoding='utf-8') as f:
        for line in f:
            walk = line.strip().split()
            if len(walk) >= 2:
                sentences.append(walk)
    
    logger.info(f"共读取 {len(sentences)} 条游走序列")
    
    # 训练Word2Vec
    logger.info("开始训练Word2Vec模型...")
    model = Word2Vec(
        sentences=sentences,
        vector_size=config['vector_size'],
        window=config['window_size'],
        min_count=config['min_count'],
        workers=config['workers'],
        sg=config['sg'],
        epochs=config['epochs'],
        seed=42
    )
    
    logger.info(f"训练完成。词汇表大小：{len(model.wv)}")
    return model


def generate_similarities(model, top_n, logger):
    """
    从Word2Vec模型生成物品相似度
    
    Args:
        model: Word2Vec模型
        top_n: Top N similar items
        logger: 日志对象
    
    Returns:
        Dict[item_id, List[Tuple(similar_item_id, score)]]
    """
    logger.info("生成相似度...")
    result = {}
    
    for item_id in model.wv.index_to_key:
        try:
            similar_items = model.wv.most_similar(item_id, topn=top_n)
            result[item_id] = [(sim_id, float(score)) for sim_id, score in similar_items]
        except KeyError:
            continue
    
    logger.info(f"为 {len(result)} 个物品生成了相似度")
    return result


def save_results(result, output_file, name_mappings, logger):
    """
    保存相似度结果到文件
    
    Args:
        result: 相似度字典
        output_file: 输出文件路径
        name_mappings: ID到名称的映射
        logger: 日志对象
    """
    logger.info(f"保存结果到 {output_file}...")
    
    with open(output_file, 'w', encoding='utf-8') as f:
        for item_id, sims in result.items():
            # 获取物品名称
            item_name = name_mappings.get(int(item_id), 'Unknown') if item_id.isdigit() else 'Unknown'
            
            if not sims:
                continue
            
            # 格式：item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
            sim_str = ','.join([f'{sim_id}:{score:.4f}' for sim_id, score in sims])
            f.write(f'{item_id}\t{item_name}\t{sim_str}\n')
    
    logger.info(f"结果保存完成")


def main():
    parser = argparse.ArgumentParser(description='Run DeepWalk for i2i similarity')
    parser.add_argument('--num_walks', type=int, default=I2I_CONFIG['deepwalk']['num_walks'],
                       help='Number of walks per node')
    parser.add_argument('--walk_length', type=int, default=I2I_CONFIG['deepwalk']['walk_length'],
                       help='Walk length')
    parser.add_argument('--window_size', type=int, default=I2I_CONFIG['deepwalk']['window_size'],
                       help='Window size for Word2Vec')
    parser.add_argument('--vector_size', type=int, default=I2I_CONFIG['deepwalk']['vector_size'],
                       help='Vector size for Word2Vec')
    parser.add_argument('--min_count', type=int, default=I2I_CONFIG['deepwalk']['min_count'],
                       help='Minimum word count')
    parser.add_argument('--workers', type=int, default=I2I_CONFIG['deepwalk']['workers'],
                       help='Number of workers')
    parser.add_argument('--epochs', type=int, default=I2I_CONFIG['deepwalk']['epochs'],
                       help='Number of epochs')
    parser.add_argument('--top_n', type=int, default=DEFAULT_I2I_TOP_N,
                       help=f'Top N similar items to output (default: {DEFAULT_I2I_TOP_N})')
    parser.add_argument('--lookback_days', type=int, default=DEFAULT_LOOKBACK_DAYS,
                       help=f'Number of days to look back (default: {DEFAULT_LOOKBACK_DAYS})')
    parser.add_argument('--output', type=str, default=None,
                       help='Output file path')
    parser.add_argument('--save_model', action='store_true',
                       help='Save Word2Vec model')
    parser.add_argument('--save_graph', action='store_true',
                       help='Save graph edge file')
    parser.add_argument('--debug', action='store_true',
                       help='Enable debug mode with detailed logging and readable output')
    parser.add_argument('--use_softmax', action='store_true',
                       help='Use softmax-based alias sampling (default: False)')
    parser.add_argument('--temperature', type=float, default=1.0,
                       help='Temperature for softmax (default: 1.0)')
    
    args = parser.parse_args()
    
    # 设置logger
    logger = setup_debug_logger('i2i_deepwalk', debug=args.debug)
    
    # 记录算法参数
    params = {
        'num_walks': args.num_walks,
        'walk_length': args.walk_length,
        'window_size': args.window_size,
        'vector_size': args.vector_size,
        'min_count': args.min_count,
        'workers': args.workers,
        'epochs': args.epochs,
        'top_n': args.top_n,
        'lookback_days': args.lookback_days,
        'debug': args.debug,
        'use_softmax': args.use_softmax,
        'temperature': args.temperature
    }
    log_algorithm_params(logger, params)
    
    # 创建临时目录
    temp_dir = os.path.join(OUTPUT_DIR, 'temp')
    os.makedirs(temp_dir, exist_ok=True)
    
    date_str = datetime.now().strftime('%Y%m%d')
    edge_file = os.path.join(temp_dir, f'item_graph_{date_str}.txt')
    walks_file = os.path.join(temp_dir, f'walks_{date_str}.txt')
    
    # ============================================================
    # 步骤1: 从数据库获取数据并构建边文件
    # ============================================================
    log_processing_step(logger, "从数据库获取数据")
    
    # 创建数据库连接
    logger.info("连接数据库...")
    engine = create_db_connection(
        DB_CONFIG['host'],
        DB_CONFIG['port'],
        DB_CONFIG['database'],
        DB_CONFIG['username'],
        DB_CONFIG['password']
    )
    
    # 获取时间范围
    start_date, end_date = get_time_range(args.lookback_days)
    logger.info(f"获取数据范围：{start_date} 到 {end_date}")
    
    # SQL查询 - 获取用户行为数据
    sql_query = f"""
    SELECT 
        se.anonymous_id AS user_id,
        se.item_id,
        se.event AS event_type,
        pgs.name AS item_name
    FROM 
        sensors_events se
    LEFT JOIN prd_goods_sku pgs ON se.item_id = pgs.id
    WHERE 
        se.event IN ('click', 'contactFactory', 'addToPool', 'addToCart', 'purchase')
        AND se.create_time >= '{start_date}'
        AND se.create_time <= '{end_date}'
        AND se.item_id IS NOT NULL
        AND se.anonymous_id IS NOT NULL
    """
    
    logger.info("执行SQL查询...")
    df = pd.read_sql(sql_query, engine)
    logger.info(f"获取到 {len(df)} 条记录")
    
    # 记录数据信息
    log_dataframe_info(logger, df, "用户行为数据")
    
    # 定义行为权重
    behavior_weights = {
        'click': 1.0,
        'contactFactory': 5.0,
        'addToPool': 2.0,
        'addToCart': 3.0,
        'purchase': 10.0
    }
    logger.debug(f"行为权重: {behavior_weights}")
    
    # 构建边文件
    log_processing_step(logger, "构建边文件")
    num_nodes = build_edge_file_from_db(df, behavior_weights, edge_file, logger)
    
    # ============================================================
    # 步骤2: 使用DeepWalk进行随机游走
    # ============================================================
    log_processing_step(logger, "执行DeepWalk随机游走")
    
    logger.info("初始化DeepWalk...")
    deepwalk = DeepWalk(
        edge_file=edge_file,
        node_tag_file=None,  # 不使用标签游走
        use_softmax=args.use_softmax,
        temperature=args.temperature,
        p_tag_walk=0.0  # 不使用标签游走
    )
    
    logger.info("开始随机游走...")
    deepwalk.simulate_walks(
        num_walks=args.num_walks,
        walk_length=args.walk_length,
        workers=args.workers,
        output_file=walks_file
    )
    
    # ============================================================
    # 步骤3: 训练Word2Vec模型
    # ============================================================
    log_processing_step(logger, "训练Word2Vec模型")
    
    w2v_config = {
        'vector_size': args.vector_size,
        'window_size': args.window_size,
        'min_count': args.min_count,
        'workers': args.workers,
        'epochs': args.epochs,
        'sg': 1  # Skip-gram
    }
    logger.debug(f"Word2Vec配置: {w2v_config}")
    
    model = train_word2vec_from_walks(walks_file, w2v_config, logger)
    
    # 保存模型（可选）
    if args.save_model:
        model_path = os.path.join(OUTPUT_DIR, f'deepwalk_model_{date_str}.model')
        model.save(model_path)
        logger.info(f"模型已保存到 {model_path}")
    
    # ============================================================
    # 步骤4: 生成相似度
    # ============================================================
    log_processing_step(logger, "生成相似度")
    result = generate_similarities(model, args.top_n, logger)
    
    # ============================================================
    # 步骤5: 保存结果
    # ============================================================
    log_processing_step(logger, "保存结果")
    
    output_file = args.output or os.path.join(OUTPUT_DIR, f'i2i_deepwalk_{date_str}.txt')
    
    # 获取name mappings
    name_mappings = {}
    if args.debug:
        logger.info("获取物品名称映射...")
        name_mappings = fetch_name_mappings(engine, debug=True)
    
    save_results(result, output_file, name_mappings, logger)
    
    logger.info(f"✓ DeepWalk完成！")
    logger.info(f"  - 输出文件: {output_file}")
    logger.info(f"  - 商品数: {len(result)}")
    if result:
        avg_sims = sum(len(sims) for sims in result.values()) / len(result)
        logger.info(f"  - 平均相似商品数: {avg_sims:.1f}")
    
    # 如果启用debug模式，保存可读格式
    if args.debug:
        log_processing_step(logger, "保存Debug可读格式")
        save_readable_index(
            output_file,
            result,
            name_mappings,
            description='i2i:deepwalk'
        )
    
    # 清理临时文件（可选）
    if not args.save_graph:
        if os.path.exists(edge_file):
            os.remove(edge_file)
            logger.debug(f"已删除临时文件: {edge_file}")
    if os.path.exists(walks_file):
        os.remove(walks_file)
        logger.debug(f"已删除临时文件: {walks_file}")
    
    print(f"✓ DeepWalk相似度计算完成")
    print(f"  - 输出文件: {output_file}")
    print(f"  - 商品数: {len(result)}")


if __name__ == '__main__':
    main()