import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:tm_app/data/repositories/tenders_repository.dart';
import 'package:tm_app/data/services/model/feedback_data/feedback_data.dart';
import 'package:tm_app/data/services/model/feedback_response/feedback_response.dart';
import 'package:tm_app/data/services/model/tender_approvals_toggle_data/tender_approvals_toggle_data.dart';
import 'package:tm_app/data/services/model/tender_approvals_toggle_response/tender_approvals_toggle_response.dart';
import 'package:tm_app/data/services/model/tenders/tenders_response/tenders_response.dart';

import '../core/utils/result.dart';
import '../data/services/model/tender_approvals_by_id_response/tender_approvals_by_id_response.dart';
import '../data/services/model/tender_approvals_data/tender_approvals_data.dart';

class TendersViewModel with ChangeNotifier {
  final TendersRepository _tendersRepository;

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

  bool _isLoading = false;
  bool _isLoadingMore = false;
  String? _errorMessage;
  String? _feedbackErrorMessage;
  String? _tenderApprovalErrorMessage;
  TendersResponse? _tendersResponse;
  FeedbackData? _feedbackData;
  TenderApprovalsData? _tenderApprovalData;
  TenderApprovalsToggleData? _tenderApprovalToggleData;

  bool get isLoading => _isLoading;
  bool get isLoadingMore => _isLoadingMore;
  String? get errorMessage => _errorMessage;
  String? get feedbackErrorMessage => _feedbackErrorMessage;
  String? get tenderApprovalErrorMessage => _tenderApprovalErrorMessage;
  TendersResponse? get tendersResponse => _tendersResponse;
  FeedbackData? get feedbackData => _feedbackData;
  TenderApprovalsData? get tenderApprovalData => _tenderApprovalData;
  TenderApprovalsToggleData? get tenderApprovalToggleData =>
      _tenderApprovalToggleData;

  List<FeedbackData> feedbacks = [];
  List<TenderApprovalsData> tenderApprovals = [];

  int currentPage = 1;
  int _currentOffset = 0;
  static const int _pageSize = 10;
  bool _hasMoreData = true;

  bool get hasMoreData => _hasMoreData;

  /// Get feedback for a specific tender
  FeedbackData? getFeedbackForTender(String tenderId) {
    try {
      return feedbacks.firstWhere((f) => f.tender == tenderId);
    } catch (e) {
      return null;
    }
  }

  /// Check if feedback exists for a specific tender
  bool hasFeedbackForTender(String tenderId) {
    return feedbacks.any((f) => f.tender == tenderId);
  }

  /// Get tender approval for a specific tender
  TenderApprovalsData? getTenderApprovalForTender(String tenderId) {
    try {
      return tenderApprovals.firstWhere((a) => a.tenderId == tenderId);
    } catch (e) {
      return null;
    }
  }

  /// Check if tender approval exists for a specific tender
  bool hasTenderApprovalForTender(String tenderId) {
    return tenderApprovals.any((a) => a.tenderId == tenderId);
  }

  /// Get approval status for a specific tender
  String? getApprovalStatusForTender(String tenderId) {
    final approval = getTenderApprovalForTender(tenderId);
    return approval?.status;
  }

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

    final result = await _tendersRepository.getTenders(
      limit: _pageSize,
      offset: _currentOffset,
    );
    switch (result) {
      case Ok<TendersResponse>():
        _tendersResponse = result.value;
        // Check if we have more data
        if (_tendersResponse?.data?.tenders != null) {
          _hasMoreData = _tendersResponse!.data!.tenders!.length >= _pageSize;
        }
        if (_tendersResponse?.data?.tenders?.isNotEmpty == true) {
          // Fetch feedback and approvals for the first tender only
          getTenderFeedback(_tendersResponse!.data!.tenders!.first.id!);
          getTenderApprovals(_tendersResponse!.data!.tenders!.first.id!);
        }
        break;
      case Error<TendersResponse>():
        _errorMessage = result.error.toString();
        break;
    }
    _isLoading = false;
    notifyListeners();
    _errorMessage = null;
    notifyListeners();
  }

  Future<void> loadMoreTenders() async {
    if (_isLoadingMore || !_hasMoreData) {
      return;
    }

    _isLoadingMore = true;
    _errorMessage = null;
    notifyListeners();

    _currentOffset += _pageSize;
    final result = await _tendersRepository.getTenders(
      limit: _pageSize,
      offset: _currentOffset,
    );

    switch (result) {
      case Ok<TendersResponse>():
        if (result.value.data?.tenders != null &&
            result.value.data!.tenders!.isNotEmpty) {
          // Create a new modifiable list by combining existing and new tenders
          if (_tendersResponse?.data?.tenders != null) {
            final existingTenders = _tendersResponse!.data!.tenders!;
            final newTenders = result.value.data!.tenders!;
            final combinedTenders = [...existingTenders, ...newTenders];

            // Create a new TendersData with the combined list
            _tendersResponse = _tendersResponse!.copyWith(
              data: _tendersResponse!.data!.copyWith(tenders: combinedTenders),
            );
          } else {
            _tendersResponse = result.value;
          }
          // Check if we have more data
          _hasMoreData = result.value.data!.tenders!.length >= _pageSize;
        } else {
          _hasMoreData = false;
        }
        break;
      case Error<TendersResponse>():
        _errorMessage = result.error.toString();
        _currentOffset -= _pageSize; // Revert offset on error
        break;
    }

    _isLoadingMore = false;
    notifyListeners();
    _errorMessage = null;
    notifyListeners();
  }

  Future<void> getTenderFeedback(String tenderId) async {
    // _isLoading = true;
    _errorMessage = null;
    notifyListeners();

    final result = await _tendersRepository.getTenderFeedback(
      tenderId: tenderId,
    );
    switch (result) {
      case Ok<FeedbackResponse>():
        _feedbackData = result.value.data;
        // Add or update _feedbackData in feedbacks list by tender id
        if (_feedbackData != null) {
          final index = feedbacks.indexWhere(
            (f) => f.tender == _feedbackData!.tender,
          );
          if (index != -1) {
            feedbacks[index] = _feedbackData!;
            log('Updated feedback for tender: ${_feedbackData!.tender}');
          } else {
            feedbacks.add(_feedbackData!);
            log('Added new feedback for tender: ${_feedbackData!.tender}');
          }
          log('Total feedbacks: ${feedbacks.length}');
        }
        break;
      case Error<FeedbackResponse>():
        _errorMessage = result.error.toString();
        break;
    }
    // _isLoading = false;
    notifyListeners();
    _errorMessage = null;
    notifyListeners();
  }

  Future<void> getTenderApprovals(String tenderId) async {
    _errorMessage = null;
    notifyListeners();

    final result = await _tendersRepository.getTenderApprovals(
      tenderId: tenderId,
    );
    switch (result) {
      case Ok<TenderApprovalsByIdResponse>():
        _tenderApprovalData = result.value.data;
        // Add or update _tenderApprovalData in tenderApprovals list by tender id
        if (_tenderApprovalData != null) {
          final index = tenderApprovals.indexWhere(
            (a) => a.tenderId == _tenderApprovalData!.tenderId,
          );
          if (index != -1) {
            tenderApprovals[index] = _tenderApprovalData!;
            log(
              'Updated approval for tender: ${_tenderApprovalData!.tenderId}',
            );
          } else {
            tenderApprovals.add(_tenderApprovalData!);
            log(
              'Added new approval for tender: ${_tenderApprovalData!.tenderId}',
            );
          }
          log('Total approvals: ${tenderApprovals.length}');
        }
        break;
      case Error<TenderApprovalsByIdResponse>():
        // Remove the tender from tenderApprovals if an error occurs for this tenderId

        tenderApprovals.removeWhere((a) => a.tenderId == tenderId);
        _errorMessage = result.error.toString();
        break;
    }
    notifyListeners();
    _errorMessage = null;
    notifyListeners();
  }

  Future<void> feedback({
    required String tenderId,
    required String feedbackType,
  }) async {
    _feedbackErrorMessage = null;
    notifyListeners();

    final result = await _tendersRepository.feedback(
      tenderId: tenderId,
      feedbackType: feedbackType,
    );
    switch (result) {
      case Ok<FeedbackResponse>():
        _feedbackData = result.value.data;
        if (_feedbackData != null) {
          final index = feedbacks.indexWhere(
            (f) => f.tender == _feedbackData!.tender,
          );
          if (index != -1) {
            feedbacks[index] = _feedbackData!;
          } else {
            feedbacks.add(_feedbackData!);
          }
        }
        break;
      case Error<FeedbackResponse>():
        _feedbackErrorMessage = result.error.toString();
        break;
    }
    notifyListeners();
    _feedbackErrorMessage = null;
    notifyListeners();
  }

  Future<void> toggleApprovals({
    required String tenderId,
    required String submissionMode,
    required String status,
  }) async {
    _tenderApprovalErrorMessage = null;
    notifyListeners();
    final result = await _tendersRepository.toggleApprovals(
      tenderId: tenderId,
      submissionMode: submissionMode,
      status: status,
    );
    switch (result) {
      case Ok<TenderApprovalsToggleResponse>():
        _tenderApprovalToggleData = result.value.data;
        if (_tenderApprovalToggleData != null) {
          // Convert TenderApprovalsToggleData to TenderApprovalsData
          final approvalData = TenderApprovalsData(
            id: _tenderApprovalToggleData!.id,
            status: _tenderApprovalToggleData!.status!,
            tenderId: _tenderApprovalToggleData!.tenderId,
            companyId: _tenderApprovalToggleData!.companyId,
            submissionMode: _tenderApprovalToggleData!.submissionMode,
            createdAt: _tenderApprovalToggleData!.createdAt,
            tender: null, // Tender data is not included in toggle response
          );

          final index = tenderApprovals.indexWhere(
            (a) => a.tenderId == approvalData.tenderId,
          );
          if (index != -1) {
            tenderApprovals[index] = approvalData;
          } else {
            tenderApprovals.add(approvalData);
          }
        }
        break;
      case Error<TenderApprovalsToggleResponse>():
        _tenderApprovalErrorMessage = result.error.toString();
        break;
    }
    notifyListeners();
    _tenderApprovalErrorMessage = null;
    notifyListeners();
  }
}