import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:ristoris/ui/pages/payments/payments_page.dart';
import '../../core/constants.dart';
import '../../database/database.dart';
import 'database_provider.dart';
import '../../services/auth_service.dart';
import 'article_provider.dart';
import 'customer_provider.dart';
import 'dashboard_provider.dart';
import 'order_provider.dart';
import 'sync_provider.dart';

const _kRememberedUsername = 'REMEMBERED_USERNAME';
const _kRememberedPassword = 'REMEMBERED_PASSWORD';

class AuthState {
  final Agente? agente;
  final bool isLoading;
  final bool isInitialized;
  final String? error;

  const AuthState({
    this.agente,
    this.isLoading = false,
    this.isInitialized = false,
    this.error,
  });

  bool get isLoggedIn => agente != null;
}

final authServiceProvider = Provider<AuthService>((ref) {
  return AuthService(
    ref.read(agentiDaoProvider),
    ref.read(apiServiceProvider),
    ref.read(parametriDaoProvider),
  );
});

class AuthNotifier extends Notifier<AuthState> {
  @override
  AuthState build() {
    _checkInitialized();
    return const AuthState();
  }

  Future<void> _checkInitialized() async {
    final authService = ref.read(authServiceProvider);
    final initialized = await authService.isInitialized();
    state = AuthState(isInitialized: initialized);
  }

  Future<void> login(
    String code,
    String password,
    String url, {
    bool rememberMe = false,
  }) async {
    state = const AuthState(isLoading: true);
    try {
      final dao = ref.read(parametriDaoProvider);
      await dao.set(AppConstants.kUrlParam, url);

      final authService = ref.read(authServiceProvider);
      //print("Attempting login with code: $code, password: $password, url: $url");
      final agente = await authService.login(code, password);
      print(agente);
      if (agente != null) {
        state = AuthState(agente: agente, isInitialized: true);

        if (rememberMe) {
          await dao.set(_kRememberedUsername, code);
          await dao.set(_kRememberedPassword, password);
        } else {
          await dao.set(_kRememberedUsername, '');
          await dao.set(_kRememberedPassword, '');
        }
      } else {
        state = const AuthState(
          error: 'Codice agente o password errati',
          isInitialized: true,
        );
      }
    } catch (e) {
      state = AuthState(error: e.toString(), isInitialized: true);
    }
  }

  Future<void> initialize({
    required int idAgente,
    required String codAgente,
    required String password,
    String? ragioneSociale,
    required String url,
  }) async {
    state = const AuthState(isLoading: true);
    try {
      final authService = ref.read(authServiceProvider);
      await authService.initializeAgent(
        idAgente: idAgente,
        codAgente: codAgente,
        pwd: password,
        ragioneSociale: ragioneSociale,
        url: url,
      );
      final agente = await authService.login(codAgente, password);
      state = AuthState(agente: agente, isInitialized: true);
    } catch (e) {
      state = AuthState(error: e.toString(), isInitialized: true);
    }
  }

  void logout() {
    state = const AuthState(isInitialized: true);
  }

  Future<void> switchAgent(Agente newAgent) async {
    final agentiDao = ref.read(agentiDaoProvider);
    final agente = await agentiDao.authenticate(
      newAgent.codAgente ?? '',
      newAgent.pwd ?? '',
    );
    if (agente != null) {
      state = AuthState(agente: agente, isInitialized: true);
      ref.invalidate(articleSearchProvider);
      ref.invalidate(activeArticleSearchProvider);
      ref.invalidate(priceCodesProvider);
      ref.invalidate(customerListProvider);
      ref.invalidate(customerSearchProvider);
      ref.invalidate(customerDestinationsProvider);
      ref.invalidate(customerPaymentsProvider);
      ref.invalidate(ordersViewProvider);
      ref.invalidate(ordersSearchViewProvider);
      ref.invalidate(orderStatsProvider);
      ref.invalidate(orderProvider);
      ref.invalidate(dashboardProvider);
      ref.invalidate(paymentsProvider);
      ref.invalidate(syncProvider);
    }
  }

  void resetToInit() {
    state = const AuthState(isInitialized: false);
  }
}

final authProvider = NotifierProvider<AuthNotifier, AuthState>(
  AuthNotifier.new,
);