import 'dart:convert';

import 'package:sqflite/sqflite.dart';

import '../../domain/entities/cart.dart';
import '../../domain/entities/customer.dart';
import '../../domain/entities/product.dart';
import '../../domain/entities/transaction.dart';
import 'app_database.dart';
import 'catalogue_dao.dart';

/// Persists bills.
///
/// Every completed sale lands here with `sync_status = 0`. The end-of-day
/// upload selects those rows, sends them, and flips the accepted ones to 1.
/// Nothing is ever deleted as part of syncing.
class OrderDao {
  const OrderDao(this._db);

  final Database _db;

  static const int pending = 0;
  static const int synced = 1;

  static String businessDateOf(DateTime dt) =>
      '${dt.year.toString().padLeft(4, '0')}-'
      '${dt.month.toString().padLeft(2, '0')}-'
      '${dt.day.toString().padLeft(2, '0')}';

  // ----------------------------------------------------------------- Write
  /// Writes the bill and its lines atomically.
  Future<void> insertOrder(SaleTransaction t) async {
    final cart = t.cart;

    await _db.transaction((txn) async {
      await txn.insert(
        Tables.orders,
        {
          'id': t.id,
          'invoice_number': t.invoiceNumber,
          'created_at': t.createdAt.millisecondsSinceEpoch,
          'business_date': businessDateOf(t.createdAt),
          'cashier_name': t.cashierName,
          'terminal_id': t.terminalId,
          'customer_id': cart.customer?.id,
          'customer_mobile': cart.customer?.mobile,
          'customer_name': cart.customer?.name,
          'subtotal': cart.subtotal,
          'line_discount': cart.lineDiscountTotal,
          'bill_discount': cart.billDiscountTotal,
          'loyalty_value': cart.loyaltyRedemptionValue,
          'taxable_amount': cart.taxableAmount,
          'tax_amount': cart.taxAmount,
          'round_off': cart.roundOff,
          'total': t.total,
          'points_earned': cart.pointsEarned,
          'points_redeemed': cart.pointsRedeemed,
          'payments_json': jsonEncode([
            for (final p in t.payments)
              {
                'method': p.method.name,
                'amount': p.amount,
                'tendered': p.tendered,
                'reference': p.reference,
              },
          ]),
          'status': t.status.name,
          'sync_status': pending,
          'sync_attempts': 0,
        },
        conflictAlgorithm: ConflictAlgorithm.replace,
      );

      final batch = txn.batch();
      for (final line in cart.lines) {
        batch.insert(Tables.orderItems, {
          'order_id': t.id,
          'product_id': line.product.id,
          'name': line.product.name,
          'barcode': line.product.barcode,
          'sku': line.product.sku,
          'unit': line.product.unit.name,
          'unit_price': line.product.price,
          'quantity': line.quantity,
          'discount': line.discountAmount,
          'gst_rate': line.product.gstRate,
          'tax_amount': line.taxAmount,
          'line_total': line.payable,
        });
      }
      await batch.commit(noResult: true);
    });
  }

  // ------------------------------------------------------------------ Read
  Future<List<SaleTransaction>> recent({int limit = 100}) =>
      _query(orderBy: 'created_at DESC', limit: limit);

  Future<List<SaleTransaction>> forBusinessDate(DateTime day) =>
      _query(where: 'business_date = ?', whereArgs: [businessDateOf(day)]);

  /// The end-of-day upload set.
  Future<List<SaleTransaction>> unsynced({int limit = 500}) => _query(
        where: 'sync_status = ?',
        whereArgs: [pending],
        orderBy: 'created_at ASC',
        limit: limit,
      );

  Future<SaleTransaction?> byInvoice(String invoiceNumber) async {
    final rows = await _query(
      where: 'invoice_number = ?',
      whereArgs: [invoiceNumber],
      limit: 1,
    );
    return rows.isEmpty ? null : rows.first;
  }

  Future<int> unsyncedCount() async {
    final r = await _db.rawQuery(
      'SELECT COUNT(*) AS c FROM ${Tables.orders} WHERE sync_status = ?',
      [pending],
    );
    return r.first['c']! as int;
  }

  Future<double> salesTotalForDay(DateTime day) async {
    final r = await _db.rawQuery(
      'SELECT COALESCE(SUM(total), 0) AS t FROM ${Tables.orders} '
      "WHERE business_date = ? AND status = 'completed'",
      [businessDateOf(day)],
    );
    return (r.first['t']! as num).toDouble();
  }

  /// Sync state of an order, for display in the events log.
  Future<Map<String, Object?>?> syncRow(String orderId) async {
    final rows = await _db.query(
      Tables.orders,
      columns: [
        'id',
        'invoice_number',
        'total',
        'created_at',
        'sync_status',
        'synced_at',
        'sync_attempts',
        'sync_error',
      ],
      where: 'id = ?',
      whereArgs: [orderId],
      limit: 1,
    );
    return rows.isEmpty ? null : rows.first;
  }

  Future<List<Map<String, Object?>>> syncRows({int limit = 200}) => _db.query(
        Tables.orders,
        columns: [
          'id',
          'invoice_number',
          'total',
          'created_at',
          'sync_status',
          'synced_at',
          'sync_attempts',
          'sync_error',
        ],
        orderBy: 'created_at DESC',
        limit: limit,
      );

  // ----------------------------------------------------------------- Sync
  /// Folds accepted orders into the day archive, then deletes them.
  ///
  /// Once the server holds a bill the terminal has no reason to keep it, so
  /// the rows go. Their figures are added to [Tables.dayArchive] first, so the
  /// shift totals a cashier sees do not collapse after a mid-shift sync.
  /// Both steps run in one transaction: if the delete fails the archive is
  /// rolled back with it, and nothing is counted twice.
  Future<void> archiveAndDelete(List<SaleTransaction> orders) async {
    if (orders.isEmpty) return;

    await _db.transaction((txn) async {
      final byDate = <String, List<SaleTransaction>>{};
      for (final o in orders) {
        byDate.putIfAbsent(businessDateOf(o.createdAt), () => []).add(o);
      }

      for (final entry in byDate.entries) {
        final date = entry.key;
        final batchOrders = entry.value;

        final prior = await txn.query(
          Tables.dayArchive,
          where: 'business_date = ?',
          whereArgs: [date],
          limit: 1,
        );
        final existing = prior.isEmpty ? null : prior.first;

        final priorPayments = existing == null
            ? <String, double>{}
            : (jsonDecode(existing['payments_json']! as String)
                    as Map<String, Object?>)
                .map((k, v) => MapEntry(k, (v! as num).toDouble()));

        for (final o in batchOrders) {
          for (final p in o.payments) {
            priorPayments[p.method.name] =
                (priorPayments[p.method.name] ?? 0) + p.amount;
          }
        }

        final firsts = batchOrders
            .map((o) => o.createdAt.millisecondsSinceEpoch)
            .toList()
          ..sort();

        await txn.insert(
          Tables.dayArchive,
          {
            'business_date': date,
            'bill_count':
                ((existing?['bill_count'] as int?) ?? 0) + batchOrders.length,
            'item_count': ((existing?['item_count'] as num?)?.toDouble() ?? 0) +
                batchOrders.fold(0.0, (s, o) => s + o.cart.totalQuantity),
            'gross_sales':
                ((existing?['gross_sales'] as num?)?.toDouble() ?? 0) +
                    batchOrders.fold(0.0, (s, o) => s + o.total),
            'tax_collected':
                ((existing?['tax_collected'] as num?)?.toDouble() ?? 0) +
                    batchOrders.fold(0.0, (s, o) => s + o.cart.taxAmount),
            'discount_given':
                ((existing?['discount_given'] as num?)?.toDouble() ?? 0) +
                    batchOrders.fold(
                      0.0,
                      (s, o) =>
                          s +
                          o.cart.billDiscountTotal +
                          o.cart.lineDiscountTotal,
                    ),
            'round_off': ((existing?['round_off'] as num?)?.toDouble() ?? 0) +
                batchOrders.fold(0.0, (s, o) => s + o.cart.roundOff),
            'points_issued': ((existing?['points_issued'] as int?) ?? 0) +
                batchOrders.fold(0, (s, o) => s + o.pointsEarned),
            'points_redeemed': ((existing?['points_redeemed'] as int?) ?? 0) +
                batchOrders.fold(0, (s, o) => s + o.pointsRedeemed),
            'payments_json': jsonEncode(priorPayments),
            'first_bill_at': existing?['first_bill_at'] ?? firsts.first,
            'last_bill_at': firsts.last,
            'synced_bills':
                ((existing?['synced_bills'] as int?) ?? 0) + batchOrders.length,
          },
          conflictAlgorithm: ConflictAlgorithm.replace,
        );
      }

      // order_items goes with it via ON DELETE CASCADE.
      final ids = orders.map((o) => o.id).toList();
      final placeholders = List.filled(ids.length, '?').join(',');
      await txn.delete(
        Tables.orders,
        where: 'id IN ($placeholders)',
        whereArgs: ids,
      );
    });
  }

  /// Archived figures for a business day, or null if nothing has synced yet.
  Future<Map<String, Object?>?> dayArchive(DateTime day) async {
    final rows = await _db.query(
      Tables.dayArchive,
      where: 'business_date = ?',
      whereArgs: [businessDateOf(day)],
      limit: 1,
    );
    return rows.isEmpty ? null : rows.first;
  }

  /// Records a failed attempt. The rows stay at `sync_status = 0`.
  Future<void> markFailed(List<String> orderIds, String error) async {
    if (orderIds.isEmpty) return;
    final placeholders = List.filled(orderIds.length, '?').join(',');

    await _db.rawUpdate(
      'UPDATE ${Tables.orders} SET sync_attempts = sync_attempts + 1, '
      'sync_error = ? WHERE id IN ($placeholders)',
      [error, ...orderIds],
    );
  }

  // ---------------------------------------------------------- Parked bills
  Future<void> park(ParkedBill bill) async {
    await _db.insert(
      Tables.parkedBills,
      {
        'id': bill.id,
        'label': bill.label,
        'parked_at': bill.parkedAt.millisecondsSinceEpoch,
        'cart_json': jsonEncode(_cartToJson(bill.cart)),
      },
      conflictAlgorithm: ConflictAlgorithm.replace,
    );
  }

  Future<List<ParkedBill>> parkedBills() async {
    final rows =
        await _db.query(Tables.parkedBills, orderBy: 'parked_at DESC');
    return rows
        .map((r) => ParkedBill(
              id: r['id']! as String,
              label: r['label'] as String?,
              parkedAt:
                  DateTime.fromMillisecondsSinceEpoch(r['parked_at']! as int),
              cart: _cartFromJson(
                jsonDecode(r['cart_json']! as String) as Map<String, Object?>,
              ),
            ))
        .toList();
  }

  Future<void> removeParked(String id) async {
    await _db.delete(Tables.parkedBills, where: 'id = ?', whereArgs: [id]);
  }

  // -------------------------------------------------------------- Internals
  Future<List<SaleTransaction>> _query({
    String? where,
    List<Object?>? whereArgs,
    String orderBy = 'created_at DESC',
    int? limit,
  }) async {
    final orders = await _db.query(
      Tables.orders,
      where: where,
      whereArgs: whereArgs,
      orderBy: orderBy,
      limit: limit,
    );
    if (orders.isEmpty) return const [];

    final ids = orders.map((o) => o['id']! as String).toList();
    final placeholders = List.filled(ids.length, '?').join(',');
    final items = await _db.query(
      Tables.orderItems,
      where: 'order_id IN ($placeholders)',
      whereArgs: ids,
    );

    final byOrder = <String, List<Map<String, Object?>>>{};
    for (final i in items) {
      byOrder.putIfAbsent(i['order_id']! as String, () => []).add(i);
    }

    return orders
        .map((o) => _transactionFromRows(o, byOrder[o['id']] ?? const []))
        .toList();
  }

  SaleTransaction _transactionFromRows(
    Map<String, Object?> o,
    List<Map<String, Object?>> items,
  ) {
    // Lines are rebuilt from the snapshot taken at sale time, not from the
    // current catalogue, so a reprint always shows what was actually charged.
    final lines = items.map((i) {
      final product = Product(
        id: i['product_id']! as String,
        name: i['name']! as String,
        barcode: i['barcode']! as String,
        sku: i['sku']! as String,
        category: ProductCategory.grocery,
        price: (i['unit_price']! as num).toDouble(),
        stock: 0,
        unit: UnitOfMeasure.values.byName(i['unit']! as String),
        gstRate: (i['gst_rate']! as num).toDouble(),
      );
      return CartLine(
        product: product,
        quantity: (i['quantity']! as num).toDouble(),
        discount: (i['discount']! as num) > 0
            ? Discount(
                type: DiscountType.flat,
                value: (i['discount']! as num).toDouble(),
              )
            : Discount.none,
      );
    }).toList();

    final customerId = o['customer_id'] as String?;
    final customer = customerId == null
        ? null
        : Customer(
            id: customerId,
            name: (o['customer_name'] as String?) ?? 'Customer',
            mobile: (o['customer_mobile'] as String?) ?? '',
          );

    final payments = (jsonDecode(o['payments_json']! as String) as List)
        .cast<Map<String, Object?>>()
        .map((p) => PaymentSplit(
              method: PaymentMethod.values.byName(p['method']! as String),
              amount: (p['amount']! as num).toDouble(),
              tendered: (p['tendered'] as num?)?.toDouble(),
              reference: p['reference'] as String?,
            ))
        .toList();

    return SaleTransaction(
      id: o['id']! as String,
      invoiceNumber: o['invoice_number']! as String,
      cart: Cart(lines: lines, customer: customer),
      payments: payments,
      createdAt: DateTime.fromMillisecondsSinceEpoch(o['created_at']! as int),
      cashierName: o['cashier_name']! as String,
      terminalId: o['terminal_id']! as String,
      status: TransactionStatus.values.byName(o['status']! as String),
    );
  }

  Map<String, Object?> _cartToJson(Cart cart) => {
        'customer': cart.customer == null
            ? null
            : CatalogueDao.customerToRow(cart.customer!),
        'points_redeemed': cart.pointsRedeemed,
        'note': cart.note,
        'lines': [
          for (final l in cart.lines)
            {
              'product': CatalogueDao.productToRow(l.product),
              'quantity': l.quantity,
              'discount_type': l.discount.type.name,
              'discount_value': l.discount.value,
            },
        ],
      };

  Cart _cartFromJson(Map<String, Object?> j) {
    final customerRow = j['customer'] as Map<String, Object?>?;
    return Cart(
      customer: customerRow == null
          ? null
          : CatalogueDao.customerFromRow(customerRow),
      pointsRedeemed: (j['points_redeemed'] as int?) ?? 0,
      note: j['note'] as String?,
      lines: (j['lines'] as List).cast<Map<String, Object?>>().map((l) {
        return CartLine(
          product: CatalogueDao.productFromRow(
            l['product']! as Map<String, Object?>,
          ),
          quantity: (l['quantity']! as num).toDouble(),
          discount: Discount(
            type: DiscountType.values.byName(l['discount_type']! as String),
            value: (l['discount_value']! as num).toDouble(),
          ),
        );
      }).toList(),
    );
  }
}