import 'dart:convert';
import 'dart:developer' as dev;
import 'dart:developer';
import 'package:muaawana/models/products/products_response.dart';

import '../models/ads/Advertisement.dart';
import '../models/categories/category.dart';
import '../models/categories/category_response.dart';
import '../models/services/result.dart';
import '../models/services/service_response.dart';
import '../models/utils/api_response.dart';

import 'package:shared_preferences/shared_preferences.dart';
import 'package:http/http.dart' as http;

const url = 'server.muaawana.com';

class HomeService {
  String token = "InvalidToken";
  int statusCode = -1;
  bool errorToken = false;

  /// Fetching Jwt Token From SharedPrefs Function
  Future<String> getToken() async {
    final prefs = await SharedPreferences.getInstance();
    if (prefs.getString('token') == null || prefs.getString('token') == '') {
      prefs.setString('token', 'InvalidToken');
    }
    if (prefs.getString('token') != null) {
      token = prefs.getString('token')!;
    }
    return token.toString();
  }

  /// Fetching All Categories
  Future<APIResponse<List<Category>>> fetchAllCategories() async {
    errorToken = false;
    statusCode = -1;
    await getToken();

    return await http.get(
      Uri.https(url, '/api/v1/public/get_all_categories'),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        var categList = <Category>[];
        for (var categ in jsonData) {
          final decoded = Category.fromJson(categ);
          categList.add(decoded);
        }
        return APIResponse<List<Category>>(
            statusCode: statusCode, data: categList);
      }
      return APIResponse<List<Category>>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<List<Category>>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  /// Fetching 6 Categories
  Future<APIResponse<CategoryResponse>> fetchAllCategoriesPg(
      int page, int size) async {
    errorToken = false;
    statusCode = -1;
    // await getToken();
    final params = {'page': page.toString(), 'size': size.toString()};
    return await http.get(
      Uri.https(url, '/api/v1/public/get_all_categories_pg', params),
      headers: <String, String>{
        // 'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      log("fetchAllCategoriesPg --$data");
      log("fetchAllCategoriesPg -- data --${data.body}");
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final decoded = json.decode(data.body);
        CategoryResponse profile = CategoryResponse.fromJson(decoded);

        return APIResponse<CategoryResponse>(
            statusCode: statusCode, data: profile);
      }
      return APIResponse<CategoryResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<CategoryResponse>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  /// Fetching Services by Categories
  Future<APIResponse<ServiceResponse>> fetchServiceByCategory(
      int categoryId, int page, int size) async {
    errorToken = false;
    statusCode = -1;
    // await getToken();
    var params = {'c_id': '$categoryId', 'page': '$page', 'size': '$size'};
    return await http.get(
      Uri.https(url, '/api/v1/public/get_all_services_by_category_pg', params),
      headers: <String, String>{
        // 'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {

      log("fetchServiceByCategory -- ${data.body}");
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {

        final jsonData = json.decode(data.body);

        final result = ServiceResponse.fromJson(jsonData);

        return APIResponse<ServiceResponse>(
            statusCode: statusCode, data: result);
      }
      return APIResponse<ServiceResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<ServiceResponse>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  /// Fetching Services by Categories Pg :
  // fetchServicesByCategoryPg() async {
  //   //todo: Add Category params
  //   errorToken = false;
  //   statusCode = -1;
  //   await getToken();
  //   final params = {'page': 0, 'size': 6};
  //   return await http.get(
  //     Uri.https(url, '/api/v1/services/get_all_pg', params),
  //     headers: <String, String>{
  //       'Authorization': 'Bearer $token',
  //       'Content-type': 'application/json',
  //       'Accept': 'application/json'
  //     },
  //   ).then((data) {
  //     statusCode = data.statusCode;
  //     if (data.statusCode == 200 || data.statusCode == 201) {
  //       final jsonData = json.decode(data.body);
  //       log("-------> category list pg :");
  //       log(jsonData);
  //       CategoryResponse profile = CategoryResponse.fromJson(jsonData);
  //       return APIResponse<CategoryResponse>(
  //           statusCode: statusCode, data: profile);
  //     }
  //     return APIResponse<CategoryResponse>(
  //         statusCode: statusCode, errorMessage: 'Please check your info');
  //   }).catchError((_) => APIResponse<CategoryResponse>(
  //       statusCode: statusCode, errorMessage: 'no internet connection'));
  // }

  /// Fetching Products by Categories
  Future<APIResponse<ProductsResponse>> fetchProductsByCategory(
      int categoryId, int page, int size) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    var params = {'c_id': '$categoryId', 'page': '$page', 'size': '$size'};
    dev.log("fetchProductsByCategory --c_id- $categoryId");
    return await http.get(
      Uri.https(url, '/api/v1/public/get_all_product_by_category_pg', params),
      headers: <String, String>{
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        dev.log("fetchProductsByCategory --- $data");
        final jsonData = json.decode(data.body);
        final result = ProductsResponse.fromJson(jsonData);

        return APIResponse<ProductsResponse>(
            statusCode: statusCode, data: result);
      }
      dev.log("errrorrrrrrrr");
      return APIResponse<ProductsResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<ProductsResponse>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<ProductsResponse>> fetchProducts(int page, int size) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    var params = { 'page': '$page', 'size': '$size'};
    return await http.get(
      Uri.https(url, '/api/v1/public/get_all_product', params),
      headers: <String, String>{
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        dev.log("fetchProducts --- $data");
        final jsonData = json.decode(data.body);
        final result = ProductsResponse.fromJson(jsonData);

        return APIResponse<ProductsResponse>(
            statusCode: statusCode, data: result);
      }
      dev.log("errrorrrrrrrr");
      return APIResponse<ProductsResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<ProductsResponse>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  /// Fetching Products By Category PG
  // fetchProductsByCategoryPg() async {
  //   //todo: Add Category params
  //   errorToken = false;
  //   statusCode = -1;
  //   await getToken();
  //   final params = {'page': 0, 'size': 6};
  //   return await http.get(
  //     Uri.https(url, '/api/v1/products/get_all_pg', params),
  //     headers: <String, String>{
  //       'Authorization': 'Bearer $token',
  //       'Content-type': 'application/json',
  //       'Accept': 'application/json'
  //     },
  //   ).then((data) {
  //     statusCode = data.statusCode;
  //     if (data.statusCode == 200 || data.statusCode == 201) {
  //       final jsonData = json.decode(data.body);
  //       log("-------> category list pg :");
  //       log(jsonData);
  //       CategoryResponse profile = CategoryResponse.fromJson(jsonData);
  //       return APIResponse<CategoryResponse>(
  //           statusCode: statusCode, data: profile);
  //     }
  //     return APIResponse<CategoryResponse>(
  //         statusCode: statusCode, errorMessage: 'Please check your info');
  //   }).catchError((_) => APIResponse<CategoryResponse>(
  //       statusCode: statusCode, errorMessage: 'no internet connection'));
  // }

  /// fetch Service Detail
  Future<APIResponse<Service>> getServiceDetail(int serviceId) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.get(
      Uri.https(
        url,
        '/api/v1/services/get_by_user/$serviceId',
      ),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        final result = Service.fromJson(jsonData);
        //print(result);
        //print("decoded service length");

        return APIResponse<Service>(statusCode: statusCode, data: result);
      }
      dev.log("errrorrrrrrrr");
      return APIResponse<Service>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<Service>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<ServiceResponse>> searchService(
      String name, int page, int size) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    var params = {'name': name, 'page': '$page', 'size': '$size'};
    return await http.get(
      Uri.https(url, 'api/v1/public/get_all_by_name_pg', params),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        final result = ServiceResponse.fromJson(jsonData);

        return APIResponse<ServiceResponse>(
            statusCode: statusCode, data: result);
      }
      return APIResponse<ServiceResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<ServiceResponse>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<ProductsResponse>> searchProduct(
      String name, int page, int size) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    var params = {'name': name, 'page': '$page', 'size': '$size'};
    return await http.get(
      Uri.https(url, '/api/v1/user_product/get_all_by_name_pg', params),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        final result = ProductsResponse.fromJson(jsonData);
        return APIResponse<ProductsResponse>(
            statusCode: statusCode, data: result);
      }
      dev.log("errrorrrrrrrr");
      return APIResponse<ProductsResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<ProductsResponse>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<List<Advertisement>>> fetchAds() async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.get(
      Uri.https(url, '/api/v1/public/get_all_ads'),
      headers: <String, String>{
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      log(data.body);
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        List<Advertisement> allAds = [];
        for (var ad in jsonData) {
          allAds.add(Advertisement.fromJson(ad));
        }
        //print(allAds.length);

        //print("finished !!! alright");
        return APIResponse<List<Advertisement>>(
            statusCode: statusCode, data: allAds);
      }
      //print("finished !!! error");

      return APIResponse<List<Advertisement>>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_, stacktrace) {
      log(stacktrace.toString());

      return APIResponse<List<Advertisement>>(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }
}