import 'dart:convert';
import 'dart:io';
import 'package:aitrainer_app/model/result.dart';
import 'package:aitrainer_app/service/logging.dart';
import 'package:aitrainer_app/util/common.dart';
import 'package:aitrainer_app/util/not_found_exception.dart';
import 'package:flutter/services.dart';
import 'package:http/http.dart' as http;
import 'package:aitrainer_app/model/cache.dart';

class APIClient with Common, Logging {
  Future<dynamic> sendRequestToServer(dynamic model, String reqType, bool isTokenHeader, String token) async {
    HttpClient client = new HttpClient();
    client.badCertificateCallback = ((X509Certificate cert, String host, int port) => true);
    HttpClientRequest request = await client.postUrl(Uri.parse(Cache().getBaseUrl() + reqType));
    request.headers.set('Content-Type', 'application/json');
    if (isTokenHeader) {
      request.headers.set('Authorization', 'Bearer $token');
    }
    request.add(utf8.encode(jsonEncode(model)));
    HttpClientResponse result = await request.close();
    if (result.statusCode == 200) {
      return jsonDecode(await result.transform(utf8.decoder).join());
    } else {
      return null;
    }
  }

  dynamic authenticateUser(String email, String password) async {
    var url = Cache().getBaseUrl() + "authenticate";

    try {
      ByteData data = await rootBundle.load('asset/data/aitrainer_server.crt.pem');
      SecurityContext context = SecurityContext.defaultContext;
      context.setTrustedCertificatesBytes(data.buffer.asUint8List(), password: "[xxxx]");

      HttpClient client = new HttpClient(); //context: context Todo provide the right certificate
      client.badCertificateCallback = ((X509Certificate cert, String host, int port) {
        print("Host: $host Port: $port");
        return true;
      });
      var uri = Uri.parse(url);
      final HttpClientRequest request = await client.postUrl(uri);
      request.headers.set('Content-Type', 'application/json');
      request.headers.set('Authorization', '1');

      final body = '{"username":"$email", "password":"$password"}';
      request.write(body);
      HttpClientResponse result = await request.close();
      if (result.statusCode != 200) {
        trace("authentication response: ${result.statusCode}");
        throw Exception("Network error, try again later!");
      }
      return jsonDecode(await result.transform(utf8.decoder).join());
    } catch (exception) {
      print(exception.toString());
      throw Exception("Network error, try again later!");
    }
  }

  Future<String> post(String endPoint, String body) async {
    final url = Cache().getBaseUrl() + endPoint;
    trace(" ------------ http/post body $body - url: $url ");
    String authToken = Cache().getAuthToken();
    if (authToken.length == 0) {
      var responseJson = await this.authenticateUser(Cache.username, Cache.password);
      authToken = responseJson['token'];
      Cache().authToken = authToken;
    }
    var uri = Uri.parse(url);
    HttpClient client = new HttpClient();
    client.badCertificateCallback = ((X509Certificate cert, String host, int port) => true);
    final HttpClientRequest request = await client.getUrl(uri);
    request.headers.set('Content-Type', 'application/json');
    request.headers.set('Authorization', 'Bearer $authToken');
    request.write(body);
    HttpClientResponse result = await request.close();
    trace(" ------------post response code: " + result.statusCode.toString());
    if (result.statusCode == 200) {
      return await result.transform(utf8.decoder).join();
    } else if (result.statusCode == 404) {
      throw NotFoundException(message: "Not Found");
    } else {
      throw Exception("Network Error, please try again later");
    }
  }

  Future<String> get(String endPoint, String param) async {
    final url = Cache().getBaseUrl() + endPoint + param;

    trace("-------- API get " + url);
    String authToken = Cache().getAuthToken();
    if (authToken.length == 0) {
      var responseJson = await this.authenticateUser(Cache.username, Cache.password);
      authToken = responseJson['token'];
      Cache().authToken = authToken;
    }
    var uri = Uri.parse(url);

    HttpClient client = new HttpClient();
    client.badCertificateCallback = ((X509Certificate cert, String host, int port) => true);
    final HttpClientRequest request = await client.getUrl(uri);
    request.headers.set('Content-Type', 'application/json');
    request.headers.set('Authorization', 'Bearer $authToken');
    HttpClientResponse result = await request.close();
    trace(" ------------get response code: " + result.statusCode.toString());
    if (result.statusCode == 200) {
      return await result.transform(utf8.decoder).join();
    } else if (result.statusCode == 404) {
      throw NotFoundException(message: "Not Found");
    } else {
      throw Exception("Network Error, please try again later");
    }
  }

  Future<String> get0(String endPoint, String param) async {
    final url = Cache().getBaseUrl() + endPoint + param;

    trace("-------- API get " + url);
    String authToken = Cache().getAuthToken();
    if (authToken.length == 0) {
      var responseJson = await this.authenticateUser(Cache.username, Cache.password);
      authToken = responseJson['token'];
      Cache().authToken = authToken;
    }
    var uri = Uri.parse(url);
    final response = await http.get(uri, headers: {'Content-Type': 'application/json', 'Authorization': "Bearer " + authToken});
    trace(" ------------get response code: " + response.statusCode.toString());
    if (response.statusCode == 200) {
      return utf8.decode(response.bodyBytes);
    } else if (response.statusCode == 404) {
      throw NotFoundException(message: "Not Found");
    } else {
      throw Exception("Network Error, please try again later");
    }
  }

  Future<String> post0(String endPoint, String body) async {
    final url = Cache().getBaseUrl() + endPoint;
    trace(" ------------ http/post body $body - url: $url ");
    String authToken = Cache().getAuthToken();
    if (authToken.length == 0) {
      var responseJson = await this.authenticateUser(Cache.username, Cache.password);
      authToken = responseJson['token'];
    }
    var uri = Uri.parse(url);
    final response = await http.post(
      uri,
      headers: {'Content-Type': 'application/json; charset=UTF-8', 'Authorization': "Bearer " + authToken},
      body: body,
    );
    trace(" ------------post response code: " + response.statusCode.toString());
    final String decodedResponse = utf8convert(response.body);
    trace(" ------------ response: $decodedResponse");
    return decodedResponse;
  }

  dynamic authenticateUser0(String email, String password) async {
    var url = Cache().getBaseUrl() + "authenticate";

    try {
      final body = '{"username":"$email", "password":"$password"}';
      trace("authentication with $email");
      var uri = Uri.parse(url);
      final response = await http.post(uri, headers: {'Authorization': '1', 'Content-Type': 'application/json'}, body: body);
      final responseCode = response.statusCode;
      if (responseCode != 200) {
        trace("authentication response: $responseCode");
        throw Exception("Network error, try again later!");
        /* return {
          "error": "Authentication error, total failure",
        }; */
      }

      final responseJson = json.decode(response.body);
      return responseJson;
    } catch (exception) {
      print(exception.toString());
      throw Exception("Network error, try again later!");
    }
  }

  Future<String?> fetch(var authToken, var endPoint) async {
    var url = Cache().getBaseUrl() + endPoint;

    try {
      var uri = Uri.parse(url);
      final response = await http.get(
        uri,
        headers: {'Authorization': authToken},
      );

      final responseJson = json.decode(response.body);
      return responseJson;
    } catch (exception) {
      log(exception.toString());
      if (exception.toString().contains('SocketException')) {
        return 'NetworkError';
      } else {
        return null;
      }
    }
  }
}