import assert from 'node:assert/strict';
import 'dotenv/config';
import LibDashStore from '../src/index.js';
import { BetterSqlite3Provider } from '../src/providers/sqlite3/index.js';
import { MssqlProvider } from '../src/providers/mssql/index.js';

async function testProvider(name, provider) {
  console.log(`\n=== Testing ${name} ===`);
  await provider.initialize();
  const store = await new LibDashStore(provider);

  // 1. Setup company and user
  const email = `test-manifest-${Date.now()}@example.com`;
  const googleAuthId = await store.google_auth.add(email);
  const company = await store.company.create({
    name: `Test Manifest Corp ${Date.now()}`,
    iso639: 'de',
    taxrate: 19,
    reducedtaxrate: 7,
    googleAuthId,
  });
  await store.google_auth.setSelectedCompany(googleAuthId, company.id);

  const supplier = await store.supplier.create(googleAuthId, {
    name: 'Test Supplier',
  });
  const groups = await store.customergroup.list(googleAuthId);
  const customer = await store.entity.create(googleAuthId, {
    name: 'Test Customer',
    customergroupId: groups[0].id,
  });

  // 2. Test delivery with both dates
  console.log('Testing delivery creation with date and createdAt...');
  const deliveryDate = '2026-10-15T12:00:00.000Z';
  const customCreatedAt = '2026-09-01T08:30:00.000Z';

  const createdDelivery = await store.delivery.create(googleAuthId, {
    externalNumber: 'DEL-2DATES-1',
    supplierId: supplier.id,
    date: deliveryDate,
    createdAt: customCreatedAt,
    lines: [
      { name: 'Article 1', amount: 2, net: 50, taxrate: 19 },
    ],
  });

  assert(createdDelivery.id, 'Delivery should have an id');
  assert(createdDelivery.date, 'Delivery should have a delivery date');
  assert(createdDelivery.createdAt, 'Delivery should have createdAt');
  console.log('Delivery created:', {
    id: createdDelivery.id,
    date: createdDelivery.date,
    createdAt: createdDelivery.createdAt,
  });

  // Verify delivery getById
  const fetchedDelivery = await store.delivery.getById(googleAuthId, createdDelivery.id);
  assert.equal(new Date(fetchedDelivery.date).toISOString().slice(0, 10), '2026-10-15');
  assert.equal(new Date(fetchedDelivery.createdAt).toISOString().slice(0, 10), '2026-09-01');

  // Verify delivery update
  const updatedDeliveryDate = '2026-11-20T12:00:00.000Z';
  const updatedDelivery = await store.delivery.update(googleAuthId, createdDelivery.id, {
    date: updatedDeliveryDate,
  });
  assert.equal(new Date(updatedDelivery.date).toISOString().slice(0, 10), '2026-11-20');
  assert.equal(new Date(updatedDelivery.createdAt).toISOString().slice(0, 10), '2026-09-01');

  // Verify delivery.list ledger info before booking
  let listBefore = await store.delivery.list(googleAuthId);
  const foundBefore = listBefore.find((d) => d.id === createdDelivery.id);
  assert(foundBefore, 'Delivery should be in delivery.list');
  assert.equal(foundBefore.ledger.totalPositions, 1, 'Delivery ledger should have 1 totalPosition');
  assert.equal(foundBefore.ledger.completelyOnLedgerPositions, 0, 'Delivery ledger should have 0 completelyOnLedgerPositions initially');
  assert.equal(foundBefore.totalPositions, undefined, 'totalPositions should not be at top level');
  assert.equal(foundBefore.completelyOnLedgerPositions, undefined, 'completelyOnLedgerPositions should not be at top level');

  // Book line to ledger
  await store.ledger.add(googleAuthId, {
    manifestarticle_id: createdDelivery.lines[0].id,
    transaction_type: 'DELIVERY',
    amount: 2,
    transaction_text: `Lieferung ${createdDelivery.id}`,
  });

  // Verify delivery.list ledger info after booking
  let listAfter = await store.delivery.list(googleAuthId);
  const foundAfter = listAfter.find((d) => d.id === createdDelivery.id);
  assert(foundAfter, 'Delivery should be in delivery.list after booking');
  assert.equal(foundAfter.ledger.totalPositions, 1, 'Delivery ledger should have 1 totalPosition');
  assert.equal(foundAfter.ledger.completelyOnLedgerPositions, 1, 'Delivery ledger should have 1 completelyOnLedgerPosition after booking');
  console.log('✓ Verified delivery.list ledger info (unbooked -> booked):', foundAfter.ledger);

  // 3. Test quote with both dates
  console.log('Testing quote creation...');
  const quote = await store.quote.create(googleAuthId, {
    number: `Q-${Date.now()}`,
    date: '2026-12-01T00:00:00.000Z',
    createdAt: '2026-09-10T00:00:00.000Z',
    lines: [{ name: 'Quote item', amount: 1, net: 100, taxrate: 19 }],
  });
  assert(quote.createdAt, 'Quote should have createdAt');
  assert(quote.date, 'Quote should have date');

  // 4. Test order with default createdAt
  console.log('Testing order creation with default createdAt...');
  const order = await store.order.create(googleAuthId, {
    number: `ORD-${Date.now()}`,
    date: '2026-12-15T00:00:00.000Z',
    entityId: customer.id,
    lines: [{ name: 'Order item', amount: 3, net: 25, taxrate: 19 }],
  });
  assert(order.createdAt, 'Order should have default createdAt populated');
  assert(order.date, 'Order should have date');
  console.log('Order created with auto createdAt:', {
    id: order.id,
    date: order.date,
    createdAt: order.createdAt,
  });

  console.log(`✓ All tests passed for ${name}!`);
}

async function main() {
  // Test SQLite provider with existing dashback database
  const sqliteProvider = new BetterSqlite3Provider({
    filename: '/home/seb/src/dashback/data/dash.db',
  });
  try {
    await testProvider('SQLite (dash.db)', sqliteProvider);
  } finally {
    sqliteProvider.close();
  }

  // Test MSSQL provider
  const mssqlConfig = {
    server: process.env.MSSQL_SERVER,
    database: process.env.MSSQL_DATABASE,
    user: process.env.MSSQL_USER,
    password: process.env.MSSQL_PASSWORD,
    options: {
      encrypt: false,
      trustServerCertificate: true,
    },
  };
  const mssqlProvider = new MssqlProvider(mssqlConfig);
  try {
    await testProvider('MSSQL (dashback)', mssqlProvider);
  } finally {
    await mssqlProvider.close();
  }
}

main().catch((err) => {
  console.error('Test failed:', err);
  process.exit(1);
});