/**
 * 测试供应商台账功能
 * 遵循设计方案：采购-付款-物流-退库一体化流程设计方案.md
 * 章节：步骤10 - 供应商台账
 * 
 * 测试内容：
 * 1. 供应商订单列表API
 * 2. 供应商台账API（财务汇总+订单列表）
 */

const sqlite3 = require('sqlite3').verbose();
const path = require('path');

const dbPath = path.join(__dirname, 'company_finance.db');
const db = new sqlite3.Database(dbPath, (err) => {
  if (err) {
    console.error('数据库连接失败:', err.message);
    process.exit(1);
  }
  console.log('SQLite数据库连接成功:', dbPath);
});

const runSQL = (sql, params = []) => {
  return new Promise((resolve, reject) => {
    db.run(sql, params, function(err) {
      if (err) {
        reject(err);
      } else {
        resolve({ lastID: this.lastID, changes: this.changes });
      }
    });
  });
};

const runAllSQL = (sql, params = []) => {
  return new Promise((resolve, reject) => {
    db.all(sql, params, (err, rows) => {
      if (err) {
        reject(err);
      } else {
        resolve(rows);
      }
    });
  });
};

async function test() {
  let passed = 0;
  let failed = 0;
  const errors = [];
  let testSupplierId = null;
  let testProjectId = null;
  let testOrderIds = [];

  try {
    console.log('\n========================================');
    console.log('测试供应商台账功能');
    console.log('========================================\n');

    console.log('--- 测试1：创建测试数据 ---\n');
    
    const supplierCode = 'TEST-SUP-' + Date.now();
    const supplierResult = await runSQL(`
      INSERT INTO suppliers (name, supply_category, country, created_at, updated_at)
      VALUES (?, '电力设备', 'Laos', datetime('now'), datetime('now'))
    `, [supplierCode]);
    testSupplierId = supplierResult.lastID;
    console.log(`  ✅ 创建测试供应商，ID: ${testSupplierId}`);
    passed++;

    const projectCode = 'TEST-PRJ-' + Date.now();
    const projectResult = await runSQL(`
      INSERT INTO projects (code, name, status, created_at, updated_at)
      VALUES (?, '测试供应商台账项目', 'active', datetime('now'), datetime('now'))
    `, [projectCode]);
    testProjectId = projectResult.lastID;
    console.log(`  ✅ 创建测试项目，ID: ${testProjectId}`);
    passed++;

    const order1Result = await runSQL(`
      INSERT INTO purchase_orders 
      (code, project_id, supplier_id, total_amount, paid_amount, order_date, status, currency, created_at, updated_at)
      VALUES (?, ?, ?, 50000, 20000, date('now'), 'confirmed', 'CNY', datetime('now'), datetime('now'))
    `, ['TEST-PO-' + Date.now() + '-1', testProjectId, testSupplierId]);
    testOrderIds.push(order1Result.lastID);
    console.log(`  ✅ 创建测试订单1，ID: ${order1Result.lastID}，金额: 50000，已付: 20000`);
    passed++;

    const order2Result = await runSQL(`
      INSERT INTO purchase_orders 
      (code, project_id, supplier_id, total_amount, paid_amount, order_date, status, currency, created_at, updated_at)
      VALUES (?, ?, ?, 30000, 30000, date('now', '-1 day'), 'paid', 'CNY', datetime('now'), datetime('now'))
    `, ['TEST-PO-' + Date.now() + '-2', testProjectId, testSupplierId]);
    testOrderIds.push(order2Result.lastID);
    console.log(`  ✅ 创建测试订单2，ID: ${order2Result.lastID}，金额: 30000，已付: 30000`);
    passed++;

    const order3Result = await runSQL(`
      INSERT INTO purchase_orders 
      (code, project_id, supplier_id, total_amount, paid_amount, order_date, status, currency, created_at, updated_at)
      VALUES (?, ?, ?, 80000, 0, date('now', '-2 day'), 'confirmed', 'CNY', datetime('now'), datetime('now'))
    `, ['TEST-PO-' + Date.now() + '-3', testProjectId, testSupplierId]);
    testOrderIds.push(order3Result.lastID);
    console.log(`  ✅ 创建测试订单3，ID: ${order3Result.lastID}，金额: 80000，已付: 0`);
    passed++;

    console.log('\n--- 测试2：供应商订单列表API ---\n');
    
    const orders = await runAllSQL(`
      SELECT 
        po.id,
        po.code,
        po.total_amount,
        po.paid_amount,
        (po.total_amount - po.paid_amount) as unpaid_amount,
        po.order_date,
        po.status,
        p.name as project_name
      FROM purchase_orders po
      LEFT JOIN projects p ON po.project_id = p.id
      WHERE po.supplier_id = ?
      ORDER BY po.order_date DESC
    `, [testSupplierId]);
    
    if (orders.length === 3) {
      console.log(`  ✅ 订单列表查询成功，共 ${orders.length} 条记录`);
      orders.forEach((order, index) => {
        console.log(`      订单${index + 1}: ${order.code}, 金额: ${order.total_amount}, 未付: ${order.unpaid_amount}`);
      });
      passed++;
    } else {
      console.log(`  ❌ 订单数量不正确，期望3条，实际${orders.length}条`);
      failed++;
    }

    console.log('\n--- 测试3：供应商台账财务汇总 ---\n');
    
    const summary = await runAllSQL(`
      SELECT 
        COUNT(*) as order_count,
        COALESCE(SUM(total_amount), 0) as total_amount,
        COALESCE(SUM(paid_amount), 0) as paid_amount,
        COALESCE(SUM(total_amount - paid_amount), 0) as unpaid_amount
      FROM purchase_orders
      WHERE supplier_id = ?
    `, [testSupplierId]);
    
    if (summary.length > 0) {
      const s = summary[0];
      console.log(`  ✅ 财务汇总:`);
      console.log(`      订单数量: ${s.order_count}`);
      console.log(`      订单总额: ${s.total_amount}`);
      console.log(`      已付金额: ${s.paid_amount}`);
      console.log(`      未付金额: ${s.unpaid_amount}`);
      
      if (s.order_count === 3 && s.total_amount === 160000 && s.paid_amount === 50000 && s.unpaid_amount === 110000) {
        console.log(`  ✅ 财务汇总计算正确`);
        passed++;
      } else {
        console.log(`  ❌ 财务汇总计算错误`);
        console.log(`      期望: 订单数=3, 总额=160000, 已付=50000, 未付=110000`);
        failed++;
      }
    } else {
      console.log(`  ❌ 财务汇总查询失败`);
      failed++;
    }

    console.log('\n--- 测试4：验证未付金额计算 ---\n');
    console.log('  计算公式: 未付金额 = 订单总额 - 已付金额');
    console.log('  订单1: 50000 - 20000 = 30000');
    console.log('  订单2: 30000 - 30000 = 0');
    console.log('  订单3: 80000 - 0 = 80000');
    console.log('  总未付: 30000 + 0 + 80000 = 110000');
    
    const orderDetails = await runAllSQL(`
      SELECT code, total_amount, paid_amount, (total_amount - paid_amount) as unpaid_amount
      FROM purchase_orders
      WHERE supplier_id = ?
      ORDER BY code
    `, [testSupplierId]);
    
    let totalUnpaid = 0;
    orderDetails.forEach(order => {
      totalUnpaid += order.unpaid_amount;
    });
    
    if (totalUnpaid === 110000) {
      console.log(`  ✅ 未付金额计算正确: ${totalUnpaid}`);
      passed++;
    } else {
      console.log(`  ❌ 未付金额计算错误: ${totalUnpaid}`);
      failed++;
    }

    console.log('\n--- 测试5：验证订单状态显示 ---\n');
    
    const statusOrders = await runAllSQL(`
      SELECT code, status, total_amount, paid_amount
      FROM purchase_orders
      WHERE supplier_id = ?
      ORDER BY code
    `, [testSupplierId]);
    
    let statusCorrect = true;
    statusOrders.forEach(order => {
      console.log(`  订单: ${order.code}, 状态: ${order.status}`);
    });
    
    if (statusOrders.filter(o => o.status === 'confirmed').length === 2 && 
        statusOrders.filter(o => o.status === 'paid').length === 1) {
      console.log(`  ✅ 订单状态正确`);
      passed++;
    } else {
      console.log(`  ❌ 订单状态不正确`);
      failed++;
    }

    console.log('\n--- 清理测试数据 ---\n');
    for (const orderId of testOrderIds) {
      await runSQL('DELETE FROM purchase_orders WHERE id = ?', [orderId]);
    }
    await runSQL('DELETE FROM projects WHERE id = ?', [testProjectId]);
    await runSQL('DELETE FROM suppliers WHERE id = ?', [testSupplierId]);
    console.log('  测试数据已清理');

    console.log('\n========================================');
    console.log('测试结果汇总');
    console.log('========================================\n');
    console.log(`通过: ${passed}`);
    console.log(`失败: ${failed}`);
    
    if (errors.length > 0) {
      console.log('\n错误详情:');
      errors.forEach(err => console.log(`  - ${err}`));
    }

    console.log('\n========================================');
    if (failed === 0) {
      console.log('✅ 所有测试通过！供应商台账功能符合设计方案。');
    } else {
      console.log('❌ 部分测试失败，请检查错误详情。');
    }
    console.log('========================================\n');

    db.close();
    process.exit(failed > 0 ? 1 : 0);
  } catch (error) {
    console.error('测试失败:', error);
    if (testSupplierId) {
      try {
        for (const orderId of testOrderIds) {
          await runSQL('DELETE FROM purchase_orders WHERE id = ?', [orderId]);
        }
        await runSQL('DELETE FROM projects WHERE id = ?', [testProjectId]);
        await runSQL('DELETE FROM suppliers WHERE id = ?', [testSupplierId]);
      } catch (e) {}
    }
    db.close();
    process.exit(1);
  }
}

test();