import 'dart:convert';
import 'dart:io';

import 'package:csv/csv.dart';
import 'package:equatable/equatable.dart';
import 'package:file_picker/file_picker.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:formz/formz.dart';
import 'package:tunas/domains/account/models/transaction_account.dart';
import 'package:tunas/domains/account/models/transaction_category.dart';
import 'package:tunas/domains/account/models/transaction_date.dart';
import 'package:tunas/domains/account/models/transaction_description.dart';
import 'package:tunas/domains/account/models/transaction_line.dart';
import 'package:tunas/domains/account/models/transaction_value.dart';
import 'package:tunas/repositories/account/account_repository.dart';
import 'package:tunas/repositories/account/models/transaction.dart';
import 'package:uuid/uuid.dart';

part 'account_event.dart';
part 'account_state.dart';

class AccountBloc extends Bloc<AccountEvent, AccountState> {
  final AccountRepository _accountRepository;

  AccountBloc({required AccountRepository accountRepository})
      : _accountRepository = accountRepository,
        super(const AccountState()) {
    on<AccountLoad>(_onAccountLoad);
    on<AccountImportJSON>(_onAccountImportJSON);
    on<AccountImportCSV>(_onAccountImportCSV);
    // on<AccountExportJSON>(_onAccountImportJSON);
    // on<AccountExportCSV>(_onAccountImportJSON);
    on<TransactionDateChange>(_onTransactionDateChange);
    on<TransactionCategoryChange>(_onTransactionCategoryChange);
    on<TransactionDescriptionChange>(_onTransactionDescriptionChange);
    on<TransactionAccountChange>(_onTransactionAccountChange);
    on<TransactionValueChange>(_onTransactionValueChange);
    on<TransactionOpenAddDialog>(_onTransactionOpenAddDialog);
    on<TransactionHideAddDialog>(_onTransactionHideAddDialog);
    on<TransactionAdd>(_onTransactionAddDialog);
    on<TransactionSetCurrent>(_onTransactionSetCurrent);
    on<TransactionDeleteCurrent>(_onTransactionDeleteCurrent);

    _accountRepository
        .getTransactionsStream()
        .listen((transactions) => add(AccountLoad(transactions)));
  }

  _onAccountLoad(AccountLoad event, Emitter<AccountState> emit) {
    var computeResult = _computeTransactionLine(event.transactions);
    emit(state.copyWith(
      transactions: event.transactions,
      transactionsLines: computeResult.list,
      globalTotal: computeResult.globalTotal,
      accountsTotals: computeResult.accountsTotals,
      categories: computeResult.categories
    ));
  }

  _onAccountImportCSV(
      AccountImportCSV event, Emitter<AccountState> emit) async {
    FilePickerResult? result = await FilePicker.platform.pickFiles();

    final csvPath = result?.files.first.path;
    if (csvPath != null) {
      final File csv = File(csvPath);
      final String csvFileContent = await csv.readAsString();
      final List<List<dynamic>> csvList = const CsvToListConverter(fieldDelimiter: '|').convert(csvFileContent);

      final transactions = csvList
          .map((line) => Transaction(
              uuid: const Uuid().v8(),
              date: DateTime.parse(line[0]),
              category: line[1],
              description: line[2],
              account: line[3],
              value: double.parse(line[4]))
            )
          .toList();

      await _accountRepository.saveTransactions(transactions);
    }
  }

  _onAccountImportJSON(
      AccountImportJSON event, Emitter<AccountState> emit) async {
    FilePickerResult? result = await FilePicker.platform.pickFiles();

    final jsonPath = result?.files.first.path;
    if (jsonPath != null) {
      final File json = File(jsonPath);
      final String jsonString = await json.readAsString();
      final List<dynamic> jsonList = jsonDecode(jsonString);
      final List<Transaction> transactions = jsonList.map((transaction) => Transaction.fromJson(transaction)).toList();

      await _accountRepository.saveTransactions(transactions);
    }
  }

  ({List<TransactionLine> list, double globalTotal, Map<String, double> accountsTotals, List<String> categories}) _computeTransactionLine(List<Transaction> transactions) {
    double globalTotal = 0;
    Map<String, double> accountsTotals = <String, double>{};
    List<TransactionLine> output = [];
    Set<String> categories = {};

    for(var transaction in transactions) {
      double subTotal = globalTotal + transaction.value;
      globalTotal = subTotal;

      double accountTotal = accountsTotals[transaction.account] ?? 0;
      accountTotal += transaction.value;
      accountsTotals[transaction.account] = accountTotal;
      categories.add(transaction.category);

      output.add(TransactionLine(transaction: transaction, subTotal: subTotal));
    }

    output.sort((a, b) => b.transaction.date.compareTo(a.transaction.date));

    return (list: output, globalTotal: globalTotal, accountsTotals: accountsTotals, categories: categories.toList());
  }

  _onTransactionDateChange(
    TransactionDateChange event, Emitter<AccountState> emit
  ) {
    final transactionDate = TransactionDate.dirty(event.date);
    emit(state.copyWith(
      transactionDate: transactionDate,
      isValid: Formz.validate([transactionDate, state.transactionCategory, state.transactionDescription, state.transactionAccount, state.transactionValue]),
    ));
  }

  _onTransactionCategoryChange(
    TransactionCategoryChange event, Emitter<AccountState> emit
  ) {
    final transactionCategory = TransactionCategory.dirty(event.category);
    emit(state.copyWith(
      transactionCategory: transactionCategory,
      isValid: Formz.validate([state.transactionDate, transactionCategory, state.transactionDescription, state.transactionAccount, state.transactionValue]),
    ));
  }

  _onTransactionDescriptionChange(
    TransactionDescriptionChange event, Emitter<AccountState> emit
  ) {
    final transactionDescription = TransactionDescription.dirty(event.description);
    emit(state.copyWith(
      transactionDescription: transactionDescription,
      isValid: Formz.validate([state.transactionDate, state.transactionCategory, transactionDescription, state.transactionAccount, state.transactionValue]),
    ));
  }

  _onTransactionAccountChange(
    TransactionAccountChange event, Emitter<AccountState> emit
  ) {
    final transactionAccount = TransactionAccount.dirty(event.account);
    emit(state.copyWith(
      transactionAccount: transactionAccount,
      isValid: Formz.validate([state.transactionDate, state.transactionCategory, state.transactionDescription, transactionAccount, state.transactionValue]),
    ));
  }

  _onTransactionValueChange(
    TransactionValueChange event, Emitter<AccountState> emit
  ) {
    try {
      final transactionValue = TransactionValue.dirty(double.parse(event.value));
      emit(state.copyWith(
        transactionValue: transactionValue,
        isValid: Formz.validate([state.transactionDate, state.transactionCategory, state.transactionDescription, state.transactionAccount, transactionValue]),
      ));
    } catch (e) {
      const transactionValue = TransactionValue.dirty(double.infinity);
      emit(state.copyWith(
        transactionValue: transactionValue,
        isValid: Formz.validate([state.transactionDate, state.transactionCategory, state.transactionDescription, state.transactionAccount, transactionValue]),
      ));
    }
  }

  _onTransactionOpenAddDialog(
    TransactionOpenAddDialog event, Emitter<AccountState> emit
  ) {
    emit(state.copyWith(showAddDialog: true));
  }

  _onTransactionHideAddDialog(
    TransactionHideAddDialog event, Emitter<AccountState> emit
  ) {
    emit(state.copyWith(showAddDialog: false));
  }

  _onTransactionAddDialog(
    TransactionAdd event, Emitter<AccountState> emit
  ) async {
    if (state.isValid) {
      List<Transaction> transactions = state.transactions;
      Transaction? currentTransaction = state.currentTransaction;
      if (currentTransaction != null) {
        transactions.removeWhere((transaction) => transaction.uuid == currentTransaction.uuid);
      }

      transactions.add(Transaction(
        uuid: const Uuid().v8(),
        date: state.transactionDate.value ?? DateTime.now(),
        category: state.transactionCategory.value,
        description: state.transactionDescription.value,
        account: state.transactionAccount.value,
        value: state.transactionValue.value
      ));
      final computeResult = _computeTransactionLine(transactions);

      await _accountRepository.saveTransactions(transactions);
      
      emit(state.copyWith(
        currentTransaction: null,
        transactionDate: const TransactionDate.pure(),
        transactionCategory: const TransactionCategory.pure(),
        transactionDescription: const TransactionDescription.pure(),
        transactionAccount: const TransactionAccount.pure(),
        transactionValue: const TransactionValue.pure(),
        transactions: transactions,
        transactionsLines: computeResult.list,
        globalTotal: computeResult.globalTotal,
        accountsTotals: computeResult.accountsTotals,
      ));
    }
  }

  _onTransactionSetCurrent(
    TransactionSetCurrent event, Emitter<AccountState> emit
  ) {
    Transaction? transaction = event.transaction;
    if (transaction == null) {
      emit(state.copyWith(
        currentTransaction: event.transaction,
        transactionDate: const TransactionDate.pure(),
        transactionCategory: const TransactionCategory.pure(),
        transactionDescription: const TransactionDescription.pure(),
        transactionAccount: const TransactionAccount.pure(),
        transactionValue: const TransactionValue.pure(),
      ));
    } else {
      emit(state.copyWith(
        currentTransaction: transaction,
        transactionDate: TransactionDate.dirty(transaction.date),
        transactionCategory: TransactionCategory.dirty(transaction.category),
        transactionDescription: TransactionDescription.dirty(transaction.description),
        transactionAccount: TransactionAccount.dirty(transaction.account),
        transactionValue: TransactionValue.dirty(transaction.value),
      ));
    }
  }

  _onTransactionDeleteCurrent(
    TransactionDeleteCurrent event, Emitter<AccountState> emit
  ) async {
    Transaction? currentTransaction = state.currentTransaction;
    if (currentTransaction != null) {
      List<Transaction> transactions = state.transactions;
      transactions.removeWhere((transaction) => transaction.uuid == currentTransaction.uuid);
      final computeResult = _computeTransactionLine(transactions);
      await _accountRepository.saveTransactions(transactions);
      emit(state.copyWith(
        currentTransaction: null,
        transactionDate: const TransactionDate.pure(),
        transactionCategory: const TransactionCategory.pure(),
        transactionDescription: const TransactionDescription.pure(),
        transactionAccount: const TransactionAccount.pure(),
        transactionValue: const TransactionValue.pure(),
        transactions: transactions,
        transactionsLines: computeResult.list,
        globalTotal: computeResult.globalTotal,
        accountsTotals: computeResult.accountsTotals,
      ));
    }
  }
}