import 'dart:io';

import 'package:flutter/foundation.dart';
import 'package:path/path.dart' as p;
import 'package:sqflite/sqflite.dart';
import 'package:sqflite_common_ffi/sqflite_ffi.dart';

/// SQLite database for the terminal.
///
/// This is the source of truth for everything the cashier produces. Orders are
/// written here the moment a sale completes, so a crash, a power cut or a
/// closed app cannot lose a bill that has not yet reached the server.
class AppDatabase {
  AppDatabase._();

  static final AppDatabase instance = AppDatabase._();

  static const String _fileName = 'nearle_pos.db';
  static const int _version = 1;

  Database? _db;

  Database get db {
    final database = _db;
    if (database == null) {
      throw StateError('AppDatabase.open() must be called before use.');
    }
    return database;
  }

  bool get isOpen => _db != null;

  /// Opens the database, creating the schema on first run.
  ///
  /// Desktop needs the FFI factory installed first; Android and iOS use the
  /// platform implementation that ships with sqflite.
  Future<void> open({String? overridePath}) async {
    if (_db != null) return;

    if (!kIsWeb && (Platform.isWindows || Platform.isLinux || Platform.isMacOS)) {
      sqfliteFfiInit();
      databaseFactory = databaseFactoryFfi;
    }

    final path = overridePath ??
        p.join(await databaseFactory.getDatabasesPath(), _fileName);

    _db = await databaseFactory.openDatabase(
      path,
      options: OpenDatabaseOptions(
        version: _version,
        onConfigure: (db) => db.execute('PRAGMA foreign_keys = ON'),
        onCreate: (db, version) async => _createSchema(db),
        onUpgrade: (db, from, to) async {
          // Single version so far; migrations land here as the schema grows.
        },
      ),
    );
  }

  /// In-memory database for tests.
  Future<void> openInMemory() async {
    if (_db != null) await close();
    sqfliteFfiInit();
    databaseFactory = databaseFactoryFfi;
    _db = await databaseFactory.openDatabase(
      inMemoryDatabasePath,
      options: OpenDatabaseOptions(
        version: _version,
        onConfigure: (db) => db.execute('PRAGMA foreign_keys = ON'),
        onCreate: (db, version) async => _createSchema(db),
      ),
    );
  }

  Future<void> close() async {
    await _db?.close();
    _db = null;
  }

  /// Drops every row without touching the schema. Used by tests.
  Future<void> clear() async {
    final batch = db.batch();
    for (final t in const [
      Tables.orderItems,
      Tables.orders,
      Tables.products,
      Tables.customers,
      Tables.parkedBills,
      Tables.syncLog,
      Tables.meta,
    ]) {
      batch.delete(t);
    }
    await batch.commit(noResult: true);
  }

  Future<void> _createSchema(Database db) async {
    // ------------------------------------------------------------ products
    await db.execute('''
      CREATE TABLE ${Tables.products} (
        id          TEXT PRIMARY KEY,
        name        TEXT    NOT NULL,
        barcode     TEXT    NOT NULL,
        sku         TEXT    NOT NULL,
        category    TEXT    NOT NULL,
        price       REAL    NOT NULL,
        mrp         REAL,
        stock       REAL    NOT NULL DEFAULT 0,
        emoji       TEXT,
        image_url   TEXT,
        unit        TEXT    NOT NULL DEFAULT 'piece',
        gst_rate    REAL    NOT NULL DEFAULT 0.18,
        brand       TEXT,
        is_active   INTEGER NOT NULL DEFAULT 1,
        updated_at  INTEGER NOT NULL
      )
    ''');
    // Barcode lookup is the hot path during scanning.
    await db.execute(
      'CREATE UNIQUE INDEX idx_products_barcode ON ${Tables.products}(barcode)',
    );
    await db.execute(
      'CREATE INDEX idx_products_category ON ${Tables.products}(category)',
    );

    // ----------------------------------------------------------- customers
    await db.execute('''
      CREATE TABLE ${Tables.customers} (
        id             TEXT PRIMARY KEY,
        name           TEXT    NOT NULL,
        mobile         TEXT    NOT NULL,
        email          TEXT,
        gender         TEXT    NOT NULL DEFAULT 'unspecified',
        date_of_birth  INTEGER,
        loyalty_points INTEGER NOT NULL DEFAULT 0,
        lifetime_spend REAL    NOT NULL DEFAULT 0,
        visit_count    INTEGER NOT NULL DEFAULT 0,
        created_at     INTEGER,
        last_visit_at  INTEGER
      )
    ''');
    await db.execute(
      'CREATE UNIQUE INDEX idx_customers_mobile ON ${Tables.customers}(mobile)',
    );

    // -------------------------------------------------------------- orders
    await db.execute('''
      CREATE TABLE ${Tables.orders} (
        id               TEXT PRIMARY KEY,
        invoice_number   TEXT    NOT NULL UNIQUE,
        created_at       INTEGER NOT NULL,
        business_date    TEXT    NOT NULL,
        cashier_name     TEXT    NOT NULL,
        terminal_id      TEXT    NOT NULL,
        customer_id      TEXT,
        customer_mobile  TEXT,
        customer_name    TEXT,
        subtotal         REAL    NOT NULL,
        line_discount    REAL    NOT NULL DEFAULT 0,
        bill_discount    REAL    NOT NULL DEFAULT 0,
        loyalty_value    REAL    NOT NULL DEFAULT 0,
        taxable_amount   REAL    NOT NULL DEFAULT 0,
        tax_amount       REAL    NOT NULL DEFAULT 0,
        round_off        REAL    NOT NULL DEFAULT 0,
        total            REAL    NOT NULL,
        points_earned    INTEGER NOT NULL DEFAULT 0,
        points_redeemed  INTEGER NOT NULL DEFAULT 0,
        payments_json    TEXT    NOT NULL,
        status           TEXT    NOT NULL DEFAULT 'completed',

        -- 0 = held on this terminal, 1 = accepted by the server
        sync_status      INTEGER NOT NULL DEFAULT 0,
        synced_at        INTEGER,
        sync_attempts    INTEGER NOT NULL DEFAULT 0,
        sync_error       TEXT
      )
    ''');
    // The end-of-day upload selects on this, so it must be indexed.
    await db.execute(
      'CREATE INDEX idx_orders_sync ON ${Tables.orders}(sync_status)',
    );
    await db.execute(
      'CREATE INDEX idx_orders_date ON ${Tables.orders}(business_date)',
    );

    // --------------------------------------------------------- order items
    await db.execute('''
      CREATE TABLE ${Tables.orderItems} (
        id          INTEGER PRIMARY KEY AUTOINCREMENT,
        order_id    TEXT NOT NULL,
        product_id  TEXT NOT NULL,
        name        TEXT NOT NULL,
        barcode     TEXT NOT NULL,
        sku         TEXT NOT NULL,
        unit        TEXT NOT NULL,
        unit_price  REAL NOT NULL,
        quantity    REAL NOT NULL,
        discount    REAL NOT NULL DEFAULT 0,
        gst_rate    REAL NOT NULL DEFAULT 0,
        tax_amount  REAL NOT NULL DEFAULT 0,
        line_total  REAL NOT NULL,
        FOREIGN KEY (order_id) REFERENCES ${Tables.orders}(id)
          ON DELETE CASCADE
      )
    ''');
    await db.execute(
      'CREATE INDEX idx_items_order ON ${Tables.orderItems}(order_id)',
    );

    // --------------------------------------------------------- parked bills
    await db.execute('''
      CREATE TABLE ${Tables.parkedBills} (
        id         TEXT PRIMARY KEY,
        label      TEXT,
        parked_at  INTEGER NOT NULL,
        cart_json  TEXT    NOT NULL
      )
    ''');

    // -------------------------------------------------------------- syncLog
    await db.execute('''
      CREATE TABLE ${Tables.syncLog} (
        id          TEXT PRIMARY KEY,
        type        TEXT    NOT NULL,
        status      TEXT    NOT NULL,
        created_at  INTEGER NOT NULL,
        synced_at   INTEGER,
        summary     TEXT    NOT NULL,
        error       TEXT,
        attempts    INTEGER NOT NULL DEFAULT 0
      )
    ''');

    // ----------------------------------------------------------------- meta
    await db.execute('''
      CREATE TABLE ${Tables.meta} (
        key   TEXT PRIMARY KEY,
        value TEXT NOT NULL
      )
    ''');
  }
}

class Tables {
  const Tables._();

  static const String products = 'products';
  static const String customers = 'customers';
  static const String orders = 'orders';
  static const String orderItems = 'order_items';
  static const String parkedBills = 'parked_bills';
  static const String syncLog = 'sync_log';
  static const String meta = 'app_meta';
}

class MetaKeys {
  const MetaKeys._();

  static const String lastImportAt = 'last_import_at';
  static const String catalogueRevision = 'catalogue_revision';
  static const String invoiceSequence = 'invoice_sequence';
}