#!/usr/bin/env python
"""
处理 2025-10-18 23:38:23 之后的订单
执行完整的链式处理：raw_orders → products_master → procurement_orders → status sync
"""
import asyncio
import sys
from datetime import datetime

from app.services.products_master_service import ProductsMasterService
from app.services.procurement_order_service_v2 import ProcurementOrderServiceV2
from app.services.procurement_order_sync_service import ProcurementOrderSyncService
from app.core.database import AsyncSessionLocal
from sqlalchemy import text


async def check_orders_status(db):
    """检查待处理订单的状态"""
    print("\n" + "="*80)
    print("📊 检查订单状态")
    print("="*80)

    # 检查raw_orders
    result = await db.execute(text("""
        SELECT COUNT(*) as total,
               MIN(付款时间) as earliest,
               MAX(付款时间) as latest
        FROM raw_orders
        WHERE 付款时间 > '2025-10-18 23:38:23'
    """))
    row = result.fetchone()
    print(f"📦 raw_orders: {row[0]} 条订单")
    print(f"   时间范围: {row[1]} ~ {row[2]}")

    # 检查待处理订单
    result = await db.execute(text("""
        SELECT COUNT(*)
        FROM raw_orders ro
        WHERE 付款时间 > '2025-10-18 23:38:23'
        AND ro.id NOT IN (SELECT raw_order_id FROM product_source_mapping)
    """))
    unprocessed = result.scalar()
    print(f"🔄 待处理: {unprocessed} 条订单（未生成产品主表）")

    return unprocessed


async def step1_generate_products_master(db):
    """步骤1: 生成产品主表"""
    print("\n" + "="*80)
    print("📝 步骤1/3: 生成产品主表")
    print("="*80)

    service = ProductsMasterService()

    try:
        result = await service.generate_products_master(
            db=db,
            force_rebuild=False,  # 增量生成
            batch_size=1000
        )

        print(f"✅ 产品主表生成完成:")
        print(f"   - 处理订单: {result.get('processed_orders', 0)} 条")
        print(f"   - 创建产品: {result.get('created', 0)} 个")
        print(f"   - 更新产品: {result.get('updated', 0)} 个")
        print(f"   - 总产品数: {result.get('total_products', 0)} 个")

        if result.get('errors'):
            print(f"⚠️  警告: {len(result['errors'])} 个错误")
            for error in result['errors'][:5]:  # 只显示前5个
                print(f"   - {error}")

        return result

    except Exception as e:
        print(f"❌ 产品主表生成失败: {e}")
        import traceback
        traceback.print_exc()
        raise


async def step2_generate_procurement_orders(db):
    """步骤2: 生成采购订单"""
    print("\n" + "="*80)
    print("🛒 步骤2/3: 生成采购订单")
    print("="*80)

    service = ProcurementOrderServiceV2()

    try:
        result = await service.generate_procurement_orders(
            db=db,
            force_rebuild=False,  # 增量生成
            batch_size=1000
        )

        print(f"✅ 采购订单生成完成:")
        print(f"   - 创建订单: {result.get('created_orders', 0)} 条")
        print(f"   - 更新订单: {result.get('updated_orders', 0)} 条")
        print(f"   - 总订单数: {result.get('total_orders', 0)} 条")

        return result

    except Exception as e:
        print(f"❌ 采购订单生成失败: {e}")
        import traceback
        traceback.print_exc()
        raise


async def step3_sync_order_status(db):
    """步骤3: 同步采购订单状态"""
    print("\n" + "="*80)
    print("🔄 步骤3/3: 同步采购订单状态")
    print("="*80)

    service = ProcurementOrderSyncService()

    try:
        result = await service.sync_order_status(db)

        print(f"✅ 状态同步完成:")
        print(f"   - 同步订单: {result.get('synced_orders', 0)} 条")

        return result

    except Exception as e:
        print(f"❌ 状态同步失败: {e}")
        import traceback
        traceback.print_exc()
        raise


async def verify_results(db):
    """验证处理结果"""
    print("\n" + "="*80)
    print("✔️  验证处理结果")
    print("="*80)

    # 检查产品主表
    result = await db.execute(text("""
        SELECT COUNT(*)
        FROM products_master pm
        JOIN product_source_mapping psm ON pm.id = psm.product_master_id
        JOIN raw_orders ro ON psm.raw_order_id = ro.id
        WHERE ro.付款时间 > '2025-10-18 23:38:23'
    """))
    products_count = result.scalar()
    print(f"📦 产品主表: {products_count} 个产品（对应316条订单）")

    # 检查采购订单
    result = await db.execute(text("""
        SELECT COUNT(*)
        FROM procurement_orders
        WHERE 付款时间 > '2025-10-18 23:38:23'
    """))
    procurement_count = result.scalar()
    print(f"🛒 采购订单: {procurement_count} 条")

    # 检查是否还有未处理订单
    result = await db.execute(text("""
        SELECT COUNT(*)
        FROM raw_orders ro
        WHERE 付款时间 > '2025-10-18 23:38:23'
        AND ro.id NOT IN (SELECT raw_order_id FROM product_source_mapping)
    """))
    remaining = result.scalar()

    if remaining > 0:
        print(f"⚠️  警告: 仍有 {remaining} 条订单未处理")
    else:
        print(f"✅ 所有订单处理完成！")

    return {
        'products_count': products_count,
        'procurement_count': procurement_count,
        'remaining_unprocessed': remaining
    }


async def main():
    """主函数"""
    start_time = datetime.now()
    print("\n" + "="*80)
    print("🚀 开始处理 2025-10-18 23:38:23 之后的订单")
    print("="*80)
    print(f"开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")

    async with AsyncSessionLocal() as db:
        try:
            # 检查初始状态
            unprocessed = await check_orders_status(db)

            if unprocessed == 0:
                print("\n✅ 没有需要处理的订单")
                return

            # 步骤1: 生成产品主表
            products_result = await step1_generate_products_master(db)

            # 等待一秒确保数据库写入完成
            await asyncio.sleep(1)

            # 步骤2: 生成采购订单
            procurement_result = await step2_generate_procurement_orders(db)

            # 等待一秒确保数据库写入完成
            await asyncio.sleep(1)

            # 步骤3: 同步订单状态
            sync_result = await step3_sync_order_status(db)

            # 验证结果
            verify_result = await verify_results(db)

            # 完成
            end_time = datetime.now()
            duration = (end_time - start_time).total_seconds()

            print("\n" + "="*80)
            print("🎉 处理完成！")
            print("="*80)
            print(f"结束时间: {end_time.strftime('%Y-%m-%d %H:%M:%S')}")
            print(f"总耗时: {duration:.2f} 秒")
            print("\n📊 处理汇总:")
            print(f"   - 处理订单: {products_result.get('processed_orders', 0)} 条")
            print(f"   - 创建产品: {products_result.get('created', 0)} 个")
            print(f"   - 创建采购订单: {procurement_result.get('created_orders', 0)} 条")
            print(f"   - 同步订单: {sync_result.get('synced_orders', 0)} 条")
            print(f"   - 剩余未处理: {verify_result['remaining_unprocessed']} 条")

        except Exception as e:
            print(f"\n❌ 处理失败: {e}")
            import traceback
            traceback.print_exc()
            sys.exit(1)


if __name__ == "__main__":
    asyncio.run(main())