import 'package:flutter/material.dart';
import 'package:tm_app/data/repositories/tenders_repository.dart';
import 'package:tm_app/data/services/model/home/tender/tender_model.dart';
import 'package:tm_app/data/services/model/tenders/tender_dislike_response/tender_dislike_response.dart';
import 'package:tm_app/data/services/model/tenders/tender_like_response/tender_like_response.dart';
import 'package:tm_app/data/services/model/tenders/tender_reject_response/tender_reject_response.dart';
import 'package:tm_app/data/services/model/tenders/tender_submit_response/tender_submit_response.dart';
import 'package:tm_app/data/services/model/tenders/tenders_request/tenders_request.dart';
import 'package:tm_app/data/services/model/tenders/tenders_response/tenders_response.dart';

import '../core/utils/result.dart';

class TendersViewModel with ChangeNotifier {
  final TendersRepository _tendersRepository;

  TendersViewModel({required TendersRepository tendersRepository})
    : _tendersRepository = tendersRepository {
    WidgetsBinding.instance.addPostFrameCallback((_) {
      getTenders();
    });
  }

  bool _isLoading = false;
  String? _errorMessage;
  TendersResponse? _tendersResponse;

  bool get isLoading => _isLoading;
  String? get errorMessage => _errorMessage;
  TendersResponse? get tendersResponse => _tendersResponse;

  int currentPage = 1;

  Future<void> getTenders() async {
    _isLoading = true;
    _errorMessage = null;
    notifyListeners();

    final request = TendersRequest(id: 'JNDFKMDV-100JF');
    final result = await _tendersRepository.getTenders(
      tendersRequestModel: request,
    );
    switch (result) {
      case Ok<TendersResponse>():
        _tendersResponse = result.value;
        break;
      case Error<TendersResponse>():
        _errorMessage = result.error.toString();
        break;
    }
    _isLoading = false;
    notifyListeners();
    _errorMessage = null;
    notifyListeners();
  }

  /// Updates a tender's state in the list
  void _updateTenderState(
    String tenderId, {
    bool? liked,
    bool? disliked,
    bool? rejected,
    bool? submitted,
  }) {
    if (_tendersResponse?.tenders != null) {
      final updatedTenders =
          _tendersResponse!.tenders!.map((element) {
            if (element.tenderId == tenderId) {
              return element.copyWith(
                liked: liked,
                disliked: disliked,
                rejected: rejected,
                submitted: submitted,
              );
            }
            return element;
          }).toList();

      _tendersResponse = _tendersResponse!.copyWith(tenders: updatedTenders);
    }
  }

  /// Sets a tender as liked
  Future<void> markLiked(TenderModel tender) async {
    _updateTenderState(
      tender.tenderId!,
      liked: true,
      disliked: false,
      rejected: false,
      submitted: tender.submitted,
    );
    notifyListeners();
    final result = await _tendersRepository.likeTender();
    switch (result) {
      case Ok<TenderLikeResponse>():
        break;
      case Error<TenderLikeResponse>():
        break;
    }
  }

  /// Sets a tender as disliked
  Future<void> markDisliked(TenderModel tender) async {
    _updateTenderState(
      tender.tenderId!,
      disliked: true,
      liked: false,
      rejected: tender.rejected,
      submitted: false,
    );
    notifyListeners();
    final result = await _tendersRepository.dislikeTender();
    switch (result) {
      case Ok<TenderDislikeResponse>():
        break;
      case Error<TenderDislikeResponse>():
        break;
    }
  }

  /// Sets a tender as rejected
  Future<void> markRejected(TenderModel tender) async {
    _updateTenderState(
      tender.tenderId!,
      rejected: true,
      liked: false,
      disliked: tender.disliked,
      submitted: false,
    );
    notifyListeners();
    final result = await _tendersRepository.rejectTender();
    switch (result) {
      case Ok<TenderRejectResponse>():
        break;
      case Error<TenderRejectResponse>():
        break;
    }
  }

  /// Sets a tender as submitted
  Future<void> markSubmitted(TenderModel tender) async {
    _updateTenderState(
      tender.tenderId!,
      submitted: true,
      liked: tender.liked,
      disliked: false,
      rejected: false,
    );
    notifyListeners();
    final result = await _tendersRepository.submitTender();
    switch (result) {
      case Ok<TenderSubmitResponse>():
        break;
      case Error<TenderSubmitResponse>():
        break;
    }
  }

  /// Clears a specific state for a tender
  void clearTenderState(
    TenderModel tenderModel, {
    bool? isLiked,
    bool? isDisliked,
    bool? isRejected,
    bool? isSubmitted,
  }) {
    _updateTenderState(
      tenderModel.tenderId!,
      liked: isLiked ?? tenderModel.liked,
      disliked: isDisliked ?? tenderModel.disliked,
      rejected: isRejected ?? tenderModel.rejected,
      submitted: isSubmitted ?? tenderModel.submitted,
    );
  }

  /// Toggles like state for a tender
  void toggleLike(TenderModel tender) {
    if (tender.liked == true) {
      clearTenderState(tender, isLiked: false);
    } else {
      markLiked(tender);
    }
    notifyListeners();
  }

  /// Toggles dislike state for a tender
  void toggleDislike(TenderModel tender) {
    if (tender.disliked == true) {
      clearTenderState(tender, isDisliked: false);
    } else {
      markDisliked(tender);
    }
    notifyListeners();
  }

  /// Toggles reject state for a tender
  void toggleReject(TenderModel tender) {
    if (tender.rejected == true) {
      clearTenderState(tender, isRejected: false);
    } else {
      markRejected(tender);
    }
    notifyListeners();
  }

  /// Toggles submit state for a tender
  void toggleSubmit(TenderModel tender) {
    if (tender.submitted == true) {
      clearTenderState(tender, isSubmitted: false);
    } else {
      markSubmitted(tender);
    }
    notifyListeners();
  }
}