import 'package:drift/drift.dart';
import '../database/daos/ordini_dao.dart';
import '../database/daos/clienti_dao.dart';
import '../database/daos/filiali_dao.dart';
import '../database/daos/articoli_dao.dart';
import '../database/daos/listini_dao.dart';
import '../database/daos/sconti_dao.dart';
import '../database/daos/pagamenti_dao.dart';
import '../database/daos/agenti_dao.dart';
import '../database/database.dart';

class OrderManager {
  final OrdiniDao _ordiniDao;
  final ClientiDao _clientiDao;
  final FilialiDao _filialiDao;
  final ArticoliDao _articoliDao;
  final ListiniDao _listiniDao;
  final ScontiDao _scontiDao;
  final PagamentiDao _pagamentiDao;
  final AgentiDao _agentiDao;

  Ordine? _currentOrder;
  int _idAgente = 0;
  bool _isChanged = false;

  OrderManager(
    this._ordiniDao,
    this._clientiDao,
    this._filialiDao,
    this._articoliDao,
    this._listiniDao,
    this._scontiDao,
    this._pagamentiDao,
    this._agentiDao,
  );

  Ordine? get currentOrder => _currentOrder;
  bool get isChanged => _isChanged;
  set idAgente(int v) => _idAgente = v;

  void setCurrentOrder(Ordine order) {
    _currentOrder = order;
  }

  Future<Ordine> createOrder({int? idCliente}) async {
    final num = await _ordiniDao.generaNumeroOrdine(_idAgente);
    _currentOrder = Ordine(
      idOrdine: 0,
      numeroOrdine: num,
      idAgente: _idAgente,
      stato: 'N',
      dataOrdine: DateTime.now().toIso8601String(),
      idCliente: idCliente,
    );
    _isChanged = true;
    return _currentOrder!;
  }

  Future<Ordine?> loadOrder(int id) async {
    _currentOrder = await _ordiniDao.getById(id);
    _isChanged = false;
    return _currentOrder;
  }

  void setCustomer(Cliente customer) {
    if (_currentOrder == null) return;
    _currentOrder = _currentOrder!.copyWith(
      idCliente: Value<int?>(customer.idCliente),
      idPagamento: Value<int?>(customer.idPagamento),
      noteCliente: Value<String?>(customer.noteOrdine),
    );
    _isChanged = true;
  }

  void setDestination(Filiale? filiale) {
    if (_currentOrder == null) return;
    _currentOrder = _currentOrder!.copyWith(
      idFiliale: Value<int?>(filiale?.idFiliale),
    );
    _isChanged = true;
  }

  void setHeaderFields({
    int? idFiliale,
    int? idListino,
    int? idPagamento,
    String? noteCliente,
    String? noteOrdine,
    String? riferimento,
  }) {
    if (_currentOrder == null) return;
    _currentOrder = _currentOrder!.copyWith(
      idFiliale: Value<int?>(idFiliale),
      idListino: Value<int?>(idListino),
      idPagamento: Value<int?>(idPagamento),
      noteCliente: Value<String?>(noteCliente),
      noteOrdine: Value<String?>(noteOrdine),
      riferimento: Value<String?>(riferimento),
    );
    _isChanged = true;
  }

  Future<String?> calcPriceForItem(int idArticolo) async {
    final idListino = _currentOrder?.idListino;
    if (idListino == null) return null;
    final lp = await _articoliDao.getListPrice(idListino, idArticolo, '');
    if (lp != null) return lp.prezzo?.toStringAsFixed(2);
    return null;
  }

  static double calcPrezzoNetto(double lordo, double s1, double s2, double s3, double s4, double s5) {
    double netto = lordo;
    netto *= (100 - s1) / 100;
    netto *= (100 - s2) / 100;
    netto *= (100 - s3) / 100;
    netto *= (100 - s4) / 100;
    netto *= (100 - s5) / 100;
    return netto;
  }

  Future<List<RigaOrdine>> getOrderLines(int idOrdine) => _ordiniDao.getOrderLines(idOrdine);

  Future<int> addOrderLine(RigaOrdine line) async {
    if (_currentOrder == null) return 0;
    final saved = await _ordiniDao.insertOrderLine(line);
    _isChanged = true;
    return saved;
  }

  Future<void> editOrderLine(RigaOrdine line) async {
    await _ordiniDao.updateOrderLine(line);
    _isChanged = true;
  }

  Future<void> removeItem(int idRigaOrdine) async {
    await _ordiniDao.deleteOrderLine(idRigaOrdine);
    _isChanged = true;
  }

  Future<void> saveOrder() async {
    if (_currentOrder == null) return;
    if (_currentOrder!.idOrdine > 0) {
      await _ordiniDao.updateOrder(_currentOrder!);
    } else {
      final id = await _ordiniDao.insertOrder(_currentOrder!);
      _currentOrder = _currentOrder!.copyWith(idOrdine: id);
    }
    _isChanged = false;
  }

  Future<void> deleteOrder(int idOrdine) async {
    await _ordiniDao.deleteOrder(idOrdine);
    _currentOrder = null;
    _isChanged = false;
  }

  Future<double> getOrderTotal(int idOrdine) => _ordiniDao.totalAmountItems(idOrdine);
  Future<double> getOrderQty(int idOrdine) => _ordiniDao.totalQtyItems(idOrdine);
}