from flask import Blueprint, request, jsonify
import traceback
from app.utils.decorators import handle_exception
from app.services.data_loader_service import load_and_clean_data, validate_file_upload
from app.services.sku_lifecycle_service import analyze_sku_lifecycle
from app.services.spu_lifecycle_service import analyze_spu_lifecycle
from app.services.marketing_strategy_service import simulate_marketing_strategy
from app.services.insights_generator_service import generate_stage_insights
from app.services.hotproduct_analyzer_service import analyze_hotproduct
from app.services.spu_hotproduct_analyzer_service import analyze_spu_hotproduct
from app.services.cache_service import (
    get_cache_info, clear_cache,
    set_global_cache, get_global_cache
)
from app.services.supplier_resilence_service import (
    evaluator as supplier_evaluator,
    sanitize as supplier_sanitize,
    get_current_weights,
    update_weights
)

# 创建蓝图
main = Blueprint('main', __name__)

@main.route('/')
def index():
    """首页"""
    return "SKU生命周期分析系统API服务"

@main.route('/api/upload', methods=['POST'])
@handle_exception
def upload_file_route():
    """上传文件"""
    try:
        file = request.files.get('file')
        is_valid, error_msg = validate_file_upload(file)
        
        if not is_valid:
            return jsonify({'success': False, 'message': error_msg}), 400
        
        df = load_and_clean_data(file, file.filename)
        
        set_global_cache('latest_df', df)
        set_global_cache('latest_filename', file.filename)
        set_global_cache('latest_analysis_results', None)
        set_global_cache('latest_spu_analysis_results', None)
        set_global_cache('latest_hotproduct_results', None)
        set_global_cache('latest_spu_hotproduct_results', None)
        
        return jsonify({
            'success': True,
            'message': '文件上传成功',
            'filename': file.filename,
            'rows': len(df),
            'columns': list(df.columns)
        })
    except Exception as e:
        print(f"文件上传失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'文件上传失败: {str(e)}'}), 500


@main.route('/api/analyze', methods=['POST'])
@handle_exception
def analyze_file_route():
    """分析文件"""
    try:
        df = get_global_cache('latest_df')
        if df is None:
            return jsonify({'success': False, 'message': '没有可分析的数据，请先上传文件'}), 400
        
        filename = get_global_cache('latest_filename')
        results = analyze_sku_lifecycle(df, filename)
        set_global_cache('latest_analysis_results', results)
        
        return jsonify({'success': True, 'message': '分析完成', 'data': results})
    except Exception as e:
        print(f"分析失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'分析失败: {str(e)}'}), 500


@main.route('/api/results', methods=['GET'])
@handle_exception
def get_results_route():
    """获取分析结果"""
    try:
        results = get_global_cache('latest_analysis_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的分析结果，请先执行分析'}), 400
        
        return jsonify({'success': True, 'data': results})
    except Exception as e:
        print(f"获取结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取结果失败: {str(e)}'}), 500


@main.route('/api/results/<sku>', methods=['GET'])
@handle_exception
def get_result_by_sku_route(sku):
    """获取特定SKU的分析结果"""
    try:
        results = get_global_cache('latest_analysis_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的分析结果，请先执行分析'}), 400
        
        if sku not in results:
            return jsonify({'success': False, 'message': f'未找到SKU: {sku}'}), 404
        
        return jsonify({'success': True, 'data': results[sku]})
    except Exception as e:
        print(f"获取SKU结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取SKU结果失败: {str(e)}'}), 500

@main.route('/api/cache/info', methods=['GET'])
@handle_exception
def get_cache_info_route():
    """获取缓存信息"""
    return get_cache_info()

@main.route('/api/cache', methods=['DELETE'])
@handle_exception
def clear_cache_route():
    """清空缓存"""
    return clear_cache()

# 添加新的API端点以匹配前端需求
@main.route('/api/sku-lifecycle/upload', methods=['POST'])
@handle_exception
def sku_lifecycle_upload():
    """上传SKU生命周期文件"""
    return upload_file_route()


@main.route('/api/sku-lifecycle/analyze', methods=['POST'])
@handle_exception
def sku_lifecycle_analyze():
    """分析SKU生命周期"""
    return analyze_file_route()


@main.route('/api/sku-lifecycle/results', methods=['GET'])
@handle_exception
def sku_lifecycle_results():
    """获取SKU生命周期分析结果"""
    return get_results_route()


@main.route('/api/sku-lifecycle/results/<sku>', methods=['GET'])
@handle_exception
def sku_lifecycle_result_by_sku(sku):
    """获取特定SKU的生命周期分析结果"""
    return get_result_by_sku_route(sku)


@main.route('/api/spu-lifecycle/upload', methods=['POST'])
@handle_exception
def spu_lifecycle_upload():
    """上传SPU生命周期文件"""
    return upload_file_route()


@main.route('/api/spu-lifecycle/analyze', methods=['POST'])
@handle_exception
def spu_lifecycle_analyze():
    """分析SPU生命周期"""
    try:
        df = get_global_cache('latest_df')
        if df is None:
            return jsonify({'success': False, 'message': '没有可分析的数据，请先上传文件'}), 400

        filename = get_global_cache('latest_filename')
        results = analyze_spu_lifecycle(df, filename)
        set_global_cache('latest_spu_analysis_results', results)

        return jsonify({'success': True, 'message': '分析完成', 'data': results})
    except Exception as e:
        print(f"分析SPU失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'分析SPU失败: {str(e)}'}), 500


@main.route('/api/spu-lifecycle/results', methods=['GET'])
@handle_exception
def spu_lifecycle_results():
    """获取SPU生命周期分析结果"""
    try:
        results = get_global_cache('latest_spu_analysis_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的分析结果，请先执行分析'}), 400

        return jsonify({'success': True, 'data': results})
    except Exception as e:
        print(f"获取SPU结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取SPU结果失败: {str(e)}'}), 500


@main.route('/api/spu-lifecycle/results/<spu>', methods=['GET'])
@handle_exception
def spu_lifecycle_result_by_spu(spu):
    """获取特定SPU的生命周期分析结果"""
    try:
        results = get_global_cache('latest_spu_analysis_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的分析结果，请先执行分析'}), 400

        if spu not in results:
            return jsonify({'success': False, 'message': f'未找到SPU: {spu}'}), 404

        return jsonify({'success': True, 'data': results[spu]})
    except Exception as e:
        print(f"获取SPU结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取SPU结果失败: {str(e)}'}), 500

@main.route('/api/sku-lifecycle/cache/info', methods=['GET'])
@handle_exception
def sku_lifecycle_cache_info():
    """获取缓存信息"""
    return get_cache_info()

@main.route('/api/sku-lifecycle/cache', methods=['DELETE'])
@handle_exception
def sku_lifecycle_clear_cache():
    """清空缓存"""
    return clear_cache()

@main.route('/api/sku-lifecycle/strategy-simulation', methods=['POST'])
@handle_exception
def strategy_simulation():
    """营销策略模拟"""
    try:
        data = request.get_json()
        
        # 验证必需参数
        required_fields = ['revenue_series', 'quantity_series', 'date_series', 'strategy_type']
        for field in required_fields:
            if field not in data:
                return jsonify({
                    'success': False,
                    'message': f'缺少必需参数: {field}'
                }), 400
        
        revenue_series = data['revenue_series']
        quantity_series = data['quantity_series']
        date_series = data['date_series']
        stages_map = data.get('stages_map', [])
        stage_statistics = data.get('stage_statistics', {})
        strategy_type = data['strategy_type']
        strategy_params = data.get('strategy_params', {})
        
        # 执行策略模拟
        result = simulate_marketing_strategy(
            revenue_series, quantity_series, date_series,
            stages_map, stage_statistics,
            strategy_type, strategy_params
        )
        
        return jsonify({
            'success': True,
            'data': result,
            'message': '策略模拟完成'
        })
    
    except Exception as e:
        import traceback
        error_trace = traceback.format_exc()
        print(f"策略模拟失败: {str(e)}")
        print(f"错误堆栈: {error_trace}")
        return jsonify({
            'success': False,
            'message': f'策略模拟失败: {str(e)}'
        }), 400

@main.route('/api/sku-lifecycle/insights', methods=['POST'])
@handle_exception
def get_insights():
    """获取阶段洞察和策略建议"""
    try:
        data = request.get_json()
        
        # 验证必需参数
        if 'stage_statistics' not in data:
            return jsonify({
                'success': False,
                'message': '缺少必需参数: stage_statistics'
            }), 400
        
        stage_statistics = data['stage_statistics']
        current_stage = data.get('current_stage', '未知')
        is_complete = data.get('is_complete', False)
        
        # 生成洞察
        insights = generate_stage_insights(stage_statistics, current_stage, is_complete)
        
        return jsonify({
            'success': True,
            'data': insights,
            'message': '洞察生成完成'
        })
    
    except Exception as e:
        import traceback
        error_trace = traceback.format_exc()
        print(f"生成洞察失败: {str(e)}")
        print(f"错误堆栈: {error_trace}")
        return jsonify({
            'success': False,
            'message': f'生成洞察失败: {str(e)}'
        }), 400

@main.route('/api/hotproduct/analyze', methods=['POST'])
@handle_exception
def analyze_hotproduct_route():
    """分析SKU爆款系数"""
    try:
        df = get_global_cache('latest_df')
        if df is None:
            return jsonify({'success': False, 'message': '没有可分析的数据，请先上传文件'}), 400
        
        filename = get_global_cache('latest_filename')
        results = analyze_hotproduct(df, filename)
        
        if not results.get('success'):
            return jsonify(results), 400
        
        # 缓存分析结果
        set_global_cache('latest_hotproduct_results', results['data'])
        
        return jsonify(results)
    except Exception as e:
        print(f"爆款分析失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'爆款分析失败: {str(e)}'}), 500

@main.route('/api/hotproduct/results', methods=['GET'])
@handle_exception
def get_hotproduct_results_route():
    """获取爆款分析结果"""
    try:
        results = get_global_cache('latest_hotproduct_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的爆款分析结果，请先执行分析'}), 400
        
        return jsonify({'success': True, 'data': results})
    except Exception as e:
        print(f"获取爆款结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取爆款结果失败: {str(e)}'}), 500

@main.route('/api/hotproduct/results/<sku>', methods=['GET'])
@handle_exception
def get_hotproduct_result_by_sku_route(sku):
    """获取特定SKU的爆款分析结果"""
    try:
        results = get_global_cache('latest_hotproduct_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的爆款分析结果，请先执行分析'}), 400
        
        sku_results = results.get('sku_results', {})
        if sku not in sku_results:
            return jsonify({'success': False, 'message': f'未找到SKU: {sku}'}), 404
        
        return jsonify({'success': True, 'data': sku_results[sku]})
    except Exception as e:
        print(f"获取SKU爆款结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取SKU爆款结果失败: {str(e)}'}), 500


@main.route('/api/spu-hotproduct/analyze', methods=['POST'])
@handle_exception
def analyze_spu_hotproduct_route():
    """分析SPU爆款系数"""
    try:
        df = get_global_cache('latest_df')
        if df is None:
            return jsonify({'success': False, 'message': '没有可分析的数据，请先上传文件'}), 400

        filename = get_global_cache('latest_filename')
        results = analyze_spu_hotproduct(df, filename)

        if not results.get('success'):
            return jsonify(results), 400

        # 缓存分析结果
        set_global_cache('latest_spu_hotproduct_results', results['data'])

        return jsonify(results)
    except Exception as e:
        print(f"SPU爆款分析失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'SPU爆款分析失败: {str(e)}'}), 500


@main.route('/api/spu-hotproduct/results', methods=['GET'])
@handle_exception
def get_spu_hotproduct_results_route():
    """获取SPU爆款分析结果"""
    try:
        results = get_global_cache('latest_spu_hotproduct_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的爆款分析结果，请先执行分析'}), 400

        return jsonify({'success': True, 'data': results})
    except Exception as e:
        print(f"获取SPU爆款结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取SPU爆款结果失败: {str(e)}'}), 500


@main.route('/api/spu-hotproduct/results/<spu>', methods=['GET'])
@handle_exception
def get_spu_hotproduct_result_by_spu_route(spu):
    """获取特定SPU的爆款分析结果"""
    try:
        results = get_global_cache('latest_spu_hotproduct_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的爆款分析结果，请先执行分析'}), 400

        spu_results = results.get('spu_results', {})
        if spu not in spu_results:
            return jsonify({'success': False, 'message': f'未找到SPU: {spu}'}), 404

        return jsonify({'success': True, 'data': spu_results[spu]})
    except Exception as e:
        print(f"获取SPU爆款结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取SPU爆款结果失败: {str(e)}'}), 500


# 销售概览相关API
@main.route('/api/sale-overview/upload', methods=['POST'])
@handle_exception
def sale_overview_upload():
    """上传销售概览文件"""
    return upload_file_route()


@main.route('/api/sale-overview/analyze', methods=['POST'])
@handle_exception
def sale_overview_analyze():
    """分析销售概览数据"""
    try:
        df = get_global_cache('latest_df')
        if df is None:
            return jsonify({'success': False, 'message': '没有可分析的数据，请先上传文件'}), 400
        
        filename = get_global_cache('latest_filename')
        
        # 导入销售概览分析服务
        from app.services.sale_overview_service import analyze_sale_overview
        results = analyze_sale_overview(df, filename)
        set_global_cache('latest_sale_overview_results', results)
        
        return jsonify({'success': True, 'message': '分析完成', 'data': results})
    except Exception as e:
        print(f"分析销售概览失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'分析销售概览失败: {str(e)}'}), 500


@main.route('/api/sale-overview/results', methods=['GET'])
@handle_exception
def sale_overview_results():
    """获取销售概览分析结果"""
    try:
        results = get_global_cache('latest_sale_overview_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的分析结果，请先执行分析'}), 400
        
        return jsonify({'success': True, 'data': results})
    except Exception as e:
        print(f"获取销售概览结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取销售概览结果失败: {str(e)}'}), 500


# 销售趋势预测相关API
@main.route('/api/sale-trend/upload', methods=['POST'])
@handle_exception
def sale_trend_upload():
    """上传销售趋势文件"""
    return upload_file_route()


@main.route('/api/sale-trend/analyze', methods=['POST'])
@handle_exception
def sale_trend_analyze():
    """分析销售趋势数据"""
    try:
        df = get_global_cache('latest_df')
        if df is None:
            return jsonify({'success': False, 'message': '没有可分析的数据，请先上传文件'}), 400
        
        filename = get_global_cache('latest_filename')
        
        # 导入销售趋势分析服务
        from app.services.sale_trend_service import analyze_sale_trend
        results = analyze_sale_trend(df, filename)
        set_global_cache('latest_sale_trend_results', results)
        
        return jsonify({'success': True, 'message': '分析完成', 'data': results})
    except Exception as e:
        print(f"分析销售趋势失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'分析销售趋势失败: {str(e)}'}), 500


@main.route('/api/sale-trend/results', methods=['GET'])
@handle_exception
def sale_trend_results():
    """获取销售趋势分析结果"""
    try:
        results = get_global_cache('latest_sale_trend_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的分析结果，请先执行分析'}), 400
        
        return jsonify({'success': True, 'data': results})
    except Exception as e:
        print(f"获取销售趋势结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取销售趋势结果失败: {str(e)}'}), 500


@main.route('/api/sale-trend/predict', methods=['POST'])
@handle_exception
def sale_trend_predict():
    """预测销售趋势"""
    try:
        data = request.get_json()
        
        # 获取预测天数，默认为30天
        predict_days = data.get('predict_days', 30)
        
        df = get_global_cache('latest_df')
        if df is None:
            return jsonify({'success': False, 'message': '没有可分析的数据，请先上传文件'}), 400
        
        filename = get_global_cache('latest_filename')
        
        # 导入销售趋势预测服务
        from app.services.sale_trend_service import predict_sales_trend
        results = predict_sales_trend(df, filename, predict_days)
        
        return jsonify({'success': True, 'message': '预测完成', 'data': results})
    except Exception as e:
        print(f"预测销售趋势失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'预测销售趋势失败: {str(e)}'}), 500


# 促销效果分析相关API
@main.route('/api/sale-effect/upload', methods=['POST'])
@handle_exception
def sale_effect_upload():
    """上传促销效果分析文件"""
    return upload_file_route()


@main.route('/api/sale-effect/analyze', methods=['POST'])
@handle_exception
def sale_effect_analyze():
    """分析促销效果数据"""
    try:
        df = get_global_cache('latest_df')
        if df is None:
            return jsonify({'success': False, 'message': '没有可分析的数据，请先上传文件'}), 400
        
        filename = get_global_cache('latest_filename')
        
        # 导入促销效果分析服务
        from app.services.sale_effect_service import analyze_promotion_effect
        results = analyze_promotion_effect(df, filename)
        set_global_cache('latest_sale_effect_results', results)
        
        return jsonify({'success': True, 'message': '分析完成', 'data': results})
    except Exception as e:
        print(f"分析促销效果失败: {str(e)}")
        print(traceback.format_exc())
        return jsonify({'success': False, 'message': f'分析促销效果失败: {str(e)}'}), 500


@main.route('/api/sale-effect/results', methods=['GET'])
@handle_exception
def sale_effect_results():
    """获取促销效果分析结果"""
    try:
        results = get_global_cache('latest_sale_effect_results')
        if results is None:
            return jsonify({'success': False, 'message': '没有可用的分析结果，请先执行分析'}), 400
        
        return jsonify({'success': True, 'data': results})
    except Exception as e:
        print(f"获取促销效果结果失败: {str(e)}")
        return jsonify({'success': False, 'message': f'获取促销效果结果失败: {str(e)}'}), 500

# ==================== 供应商韧性评估相关 API ====================

@main.route('/api/supplier/config/weights', methods=['GET'])
@handle_exception
def get_supplier_weights():
    """获取当前供应商评估权重配置"""
    return jsonify(get_current_weights()), 200


@main.route('/api/supplier/config/weights', methods=['PUT'])
@handle_exception
def update_supplier_weights():
    """更新供应商评估权重配置"""
    data = request.get_json()
    if not data:
        return jsonify({'error': '无效的请求数据'}), 400

    required_keys = ['成本', '交付', '账期']
    if not all(key in data for key in required_keys):
        return jsonify({'error': '缺少必要的权重字段'}), 400

    try:
        weights = {key: float(data[key]) for key in required_keys}
        total = sum(weights.values())
        if abs(total - 1.0) > 0.001:
            return jsonify({'error': f'权重之和必须为1，当前总和为{total}'}), 400

        new_weights = update_weights(weights)
        return jsonify({'message': '权重更新成功', 'weights': new_weights}), 200
    except (ValueError, TypeError):
        return jsonify({'error': '权重值必须是数字'}), 400


@main.route('/api/supplier/evaluate', methods=['POST'])
@handle_exception
def evaluate_supplier_product():
    """评估产品的供应商综合得分"""
    data = request.get_json()
    if not data or 'product_code' not in data:
        return jsonify({'error': '缺少产品代码'}), 400

    product_code = data['product_code']
    # 如果前端没有传 weights，就使用当前全局权重
    weights = data.get('weights', get_current_weights())

    try:
        result_df = supplier_evaluator.evaluate_product(
            product_code=product_code,
            weights=weights
        )

        if result_df.empty:
            return jsonify({'error': '未找到该产品的评估数据'}), 404

        result_json = supplier_sanitize(result_df.to_dict(orient='records'))
        return jsonify(result_json), 200

    except Exception as e:
        print(f"评估过程中出错: {e}")
        import traceback
        print(traceback.format_exc())
        return jsonify({'error': '服务器内部错误'}), 500


@main.route('/api/supplier/product/<product_code>/details', methods=['GET'])
@handle_exception
def get_supplier_product_details(product_code):
    """获取产品在成本/交付/账期三个维度的详细评分信息"""
    try:
        details = supplier_evaluator.get_product_details(product_code)
        return jsonify(details), 200
    except Exception as e:
        print(f"获取产品详情时出错: {e}")
        import traceback
        print(traceback.format_exc())
        return jsonify({'error': '服务器内部错误'}), 500