#!/usr/bin/env python
# -*- coding: utf-8 -*-
import asyncio
import sys
import traceback
sys.path.insert(0, 'ruoyi-fastapi-backend')

from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
from sqlalchemy import select
from urllib.parse import quote_plus

# 数据库配置
DB_URL = f'mysql+asyncmy://cpy_admin:{quote_plus("Tgzz2025+")}@localhost:3307/ruoyi-fastapi'

async def test_receipt():
    engine = create_async_engine(DB_URL, echo=False)
    AsyncSession = async_sessionmaker(engine, expire_on_commit=False)
    
    async with AsyncSession() as db:
        try:
            # 导入模型
            from module_admin.entity.do.warehouse_receipt_do import WarehouseReceipt
            from module_admin.entity.do.warehouse_sample_do import WarehouseSample
            from utils.common_util import CamelCaseUtil
            
            # 查询入库单
            result = await db.execute(
                select(WarehouseReceipt).where(WarehouseReceipt.receipt_id == 685)
            )
            receipt = result.scalars().first()
            
            if receipt:
                print(f"Receipt found: {receipt.receipt_id}, {receipt.receipt_no}")
                print(f"Receipt date: {receipt.receipt_date}")
                print(f"Receipt __dict__: {receipt.__dict__}")
                
                # 转换
                try:
                    receipt_dict = CamelCaseUtil.transform_result(receipt)
                    print(f"Transformed receipt: {receipt_dict}")
                except Exception as e:
                    print(f"Transform error: {e}")
                    traceback.print_exc()
                    return
                
                # 查询样品
                result2 = await db.execute(
                    select(WarehouseSample).where(WarehouseSample.receipt_id == 685)
                )
                samples = result2.scalars().all()
                print(f"Found {len(samples)} samples")
                
                # 转换样品
                try:
                    samples_list = [CamelCaseUtil.transform_result(s) for s in samples]
                    print(f"Transformed samples: {samples_list[:2]}")
                except Exception as e:
                    print(f"Transform samples error: {e}")
                    traceback.print_exc()
                    return
                
                receipt_dict['samples'] = samples_list
                
                # 序列化日期
                def serialize_dates(obj):
                    if isinstance(obj, dict):
                        for key, value in obj.items():
                            if hasattr(value, 'isoformat'):
                                obj[key] = value.isoformat()
                            elif isinstance(value, list):
                                for item in value:
                                    serialize_dates(item)
                    return obj
                
                receipt_dict = serialize_dates(receipt_dict)
                samples_list = [serialize_dates(s) for s in samples_list]
                receipt_dict['samples'] = samples_list
                
                print(f"Final receipt_dict: {receipt_dict}")
                
                # 测试 jsonable_encoder
                from fastapi.encoders import jsonable_encoder
                try:
                    encoded = jsonable_encoder(receipt_dict)
                    print(f"jsonable_encoder success!")
                except Exception as e:
                    print(f"jsonable_encoder error: {e}")
                    traceback.print_exc()
                    
            else:
                print("Receipt not found")
                
        except Exception as e:
            print(f"Error: {e}")
            traceback.print_exc()

if __name__ == '__main__':
    asyncio.run(test_receipt())