import 'dart:ui';

import 'package:dio/dio.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:quiz_app/core/endpoint/api_endpoint.dart';
import 'package:quiz_app/core/utils/logger.dart';
import 'package:quiz_app/data/models/base/base_model.dart';
import 'package:quiz_app/data/models/quiz/library_quiz_model.dart';
import 'package:quiz_app/data/models/quiz/question_create_request.dart';
import 'package:quiz_app/data/models/quiz/quiz_listing_model.dart';
import 'package:quiz_app/data/providers/dio_client.dart';

class QuizService extends GetxService {
  late final Dio dio;

  @override
  void onInit() {
    dio = Get.find<ApiClient>().dio;
    super.onInit();
  }

  Future<bool> createQuiz(QuizCreateRequestModel request) async {
    try {
      final response = await dio.post(
        APIEndpoint.quiz,
        data: request.toJson(),
      );

      if (response.statusCode == 201) {
        return true;
      } else {
        throw Exception("Quiz creation failed");
      }
    } catch (e) {
      logC.e("Quiz creation error: $e");
      throw Exception("Quiz creation error: $e");
    }
  }

  Future<BaseResponseModel<List<RawQuizModel>>> createQuizAuto(String sentence) async {
    try {
      final response = await dio.post(
        APIEndpoint.quizGenerate,
        data: {"sentence": sentence},
      );

      if (response.statusCode == 200) {
        print(response.data);

        // Parsing response using BaseResponseModel
        final parseResponse = BaseResponseModel<List<RawQuizModel>>.fromJson(
          response.data,
          (data) => (data as List).map((item) => RawQuizModel.fromJson(item as Map<String, dynamic>)).toList(),
        );

        return parseResponse;
      } else {
        throw Exception("Quiz creation failed with status: ${response.statusCode}");
      }
    } catch (e) {
      logC.e("Quiz creation error: $e");
      throw Exception("Quiz creation error: $e");
    }
  }

  Future<BaseResponseModel<List<QuizListingModel>>?> userQuiz(String userId, int page) async {
    try {
      final response = await dio.get("${APIEndpoint.userQuiz}/$userId?page=$page");
      if (response.statusCode == 200) {
        final parsedResponse = BaseResponseModel<List<QuizListingModel>>.fromJson(
          response.data,
          (data) => (data as List).map((e) => QuizListingModel.fromJson(e as Map<String, dynamic>)).toList(),
        );
        return parsedResponse;
      } else {
        logC.e("Failed to fetch recommendation quizzes. Status: ${response.statusCode}");
        return null;
      }
    } catch (e) {
      logC.e("Error fetching user quizzes: $e");
      return null;
    }
  }

  Future<BaseResponseModel<List<QuizListingModel>>?> populerQuiz({int page = 1, int amount = 3}) async {
    try {
      Locale locale = Localizations.localeOf(Get.context!);
      final response = await dio.get("${APIEndpoint.quizPopuler}?page=$page&limit=$amount&lang_code=${locale.languageCode}");

      if (response.statusCode == 200) {
        final parsedResponse = BaseResponseModel<List<QuizListingModel>>.fromJson(
          response.data,
          (data) => (data as List).map((e) => QuizListingModel.fromJson(e as Map<String, dynamic>)).toList(),
        );
        return parsedResponse;
      } else {
        logC.e("Failed to fetch recommendation quizzes. Status: ${response.statusCode}");
        return null;
      }
    } catch (e) {
      logC.e("Error fetching recommendation quizzes: $e");
      return null;
    }
  }

  Future<BaseResponseModel<List<QuizListingModel>>?> recommendationQuiz({int page = 1, int amount = 3, String userId = ""}) async {
    try {
      Locale locale = Localizations.localeOf(Get.context!);
      final response = await dio.get("${APIEndpoint.quizRecommendation}?page=$page&limit=$amount&user_id=$userId&lang_code=${locale.languageCode}");

      if (response.statusCode == 200) {
        final parsedResponse = BaseResponseModel<List<QuizListingModel>>.fromJson(
          response.data,
          (data) => (data as List).map((e) => QuizListingModel.fromJson(e as Map<String, dynamic>)).toList(),
        );
        return parsedResponse;
      } else {
        logC.e("Failed to fetch recommendation quizzes. Status: ${response.statusCode}");
        return null;
      }
    } catch (e) {
      logC.e("Error fetching recommendation quizzes: $e");
      return null;
    }
  }

  Future<BaseResponseModel<List<QuizListingModel>>?> searchQuiz(String keyword, int page, {int limit = 10, String? subjectId}) async {
    try {
      final queryParams = {
        "keyword": keyword,
        "page": page.toString(),
        "limit": limit.toString(),
        if (subjectId != null && subjectId.isNotEmpty) "subject_id": subjectId,
      };

      final uri = Uri.parse(APIEndpoint.quizSearch).replace(queryParameters: queryParams);
      final response = await dio.getUri(uri);

      if (response.statusCode == 200) {
        final parsedResponse = BaseResponseModel<List<QuizListingModel>>.fromJson(
          response.data,
          (data) => (data as List).map((e) => QuizListingModel.fromJson(e as Map<String, dynamic>)).toList(),
        );
        return parsedResponse;
      } else {
        logC.e("Failed to fetch search quizzes. Status: ${response.statusCode}");
        return null;
      }
    } catch (e) {
      logC.e("Error fetching search quizzes: $e");
      return null;
    }
  }

  Future<BaseResponseModel<QuizData>?> getQuizById(String quizId) async {
    try {
      final response = await dio.get("${APIEndpoint.quiz}/$quizId");

      if (response.statusCode == 200) {
        final parsedResponse = BaseResponseModel<QuizData>.fromJson(
          response.data,
          (data) => QuizData.fromJson(data),
        );
        return parsedResponse;
      } else {
        logC.e("Failed to fetch quiz by id. Status: ${response.statusCode}");
        return null;
      }
    } catch (e, stacktrace) {
      logC.e("Error fetching quiz by id $e", stackTrace: stacktrace);
      return null;
    }
  }
}

class RawQuizModel {
  final String qustion;
  final dynamic answer;

  RawQuizModel({
    required this.qustion,
    required this.answer,
  });

  factory RawQuizModel.fromJson(Map<String, dynamic> json) {
    return RawQuizModel(
      qustion: json['qustion'] as String,
      answer: json['answer'],
    );
  }

  Map<String, dynamic> toJson() {
    return {
      'qustion': qustion,
      'answer': answer,
    };
  }
}