import 'dart:convert';

import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:http/http.dart';
import 'package:logger/logger.dart';
import 'package:seshat/config/constants.dart';
import 'package:seshat/domain/models/accounting.dart';
import 'package:seshat/domain/models/bal.dart';
import 'package:seshat/domain/models/bal_stats.dart';
import 'package:seshat/domain/models/book.dart';
import 'package:seshat/domain/models/book_instance.dart';
import 'package:seshat/domain/models/enums.dart';
import 'package:seshat/domain/models/owner.dart';
import 'package:seshat/domain/models/search_result.dart';
import 'package:seshat/utils/result.dart';

extension StringExtension on String {
  String capitalize() {
    return "${this[0].toUpperCase()}${this.substring(1).toLowerCase()}";
  }
}

/// API Client to manage all authenticated REST routes
class ApiClient {
  ApiClient();

  /// JWT for registration
  String? token;

  /// Readiness of the API Client
  bool isReady = false;

  /// Storage to access JWT
  FlutterSecureStorage? _secureStorage;
  Logger log = Logger(
    printer: PrettyPrinter(
      colors: true,
      lineLength: 100,
      methodCount: 0,
      dateTimeFormat: DateTimeFormat.dateAndTime,
    ),
  );

  /// Initializes connection to the [_secureStorage]
  Future<void> _initStore() async {
    _secureStorage ??= const FlutterSecureStorage();
  }

  /// Generates authorization headers and option [additionalHeaders]
  Future<Map<String, String>> _getHeaders([
    Map<String, String>? additionalHeaders,
  ]) async {
    await _initStore();
    final token = await _secureStorage!.read(key: "token");
    final headers = {"Authorization": "Bearer $token", ...?additionalHeaders};
    return headers;
  }

  /*
 * ========================
 * =====< Accounting >=====
 * ========================
*/

  /// Gets data about a BAL's needed returns
  Future<Result<Accounting>> getAccounting(int balId) async {
    final url = "https://$apiBasePath/bal/$balId/accounting";
    log.i("Fetching: getAccounting ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Accounting.fromJSON(json));
        case 403:
          throw "You don't own the specified BAL";
        case 404:
          throw "No BAL with this is exists in database";
        default:
          throw "Unknown error of code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Notifies the server that either Books, Money or All has been returned to the user
  /// [type] is the stringified version of [ReturnType]
  Future<Result<void>> returnToId(int balId, int ownerId, String type) async {
    final url =
        "https://$apiBasePath/bal/${balId.toString()}/accounting/return/${ownerId.toString()}";
    log.i("Fetching: returnToId ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders({"Content-Type": "application/json"});
      final body = jsonEncode({"return_type": type.capitalize()});
      final response = await client.post(
        Uri.parse(url),
        headers: headers,
        body: body,
      );
      switch (response.statusCode) {
        case 200:
          return Result.ok(response);
        case 403:
          throw "You don't own the specified BAL or owner";
        case 404:
          throw "No BAL or owner with this id exists in database";
        case 409:
          throw "Books and money have already been returned, or there was nothing to return";
        default:
          throw "Unknown error of code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /*
 * =================
 * =====[ BAL ]=====
 * =================
*/

  /// Get stats about a BAL's performance
  Future<Result<BalStats>> getBalStats(int balId) async {
    final url = "https://$apiBasePath/bal/${balId.toString()}/stats";
    log.i("Fetching: getBalStats ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(BalStats.fromJSON(json));
        case 403:
          throw "You don't own the specified BAL";
        case 404:
          throw "No BAL with this id exists in the database";
        case 409:
          throw "The specified BAL is not ended yet";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Stops a BAL, putting it's [BalState] to [BalState.ended]
  Future<Result<Bal>> stopBal(int balId) async {
    final url = "https://$apiBasePath/bal/${balId.toString()}/stop";
    log.i("Fetching: stopBal ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.post(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Bal.fromJSON(json));
        case 403:
          throw "You don't own the specified BAL";
        case 404:
          throw "No BAL with specified ID found";
        case 409:
          throw "Selected BAL was not on ongoing state";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Starts a BAL, putting it's [BalState] to [BalState.ongoing]
  Future<Result<Bal>> startBal(int balId) async {
    final url = "https://$apiBasePath/bal/${balId.toString()}/start";
    log.i("Fetching: startBal ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.post(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Bal.fromJSON(json));
        case 403:
          throw "You don't own the specified BAL";
        case 404:
          throw "No BAL with specified ID found";
        case 409:
          throw "Cannot have multiple BAl ongoing at the same time!";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Changes the information about a [Bal], such as its [name], [startTime] or [endTime]
  Future<Result<Bal>> editBal(
    int balId,
    String name,
    DateTime startTime,
    DateTime endTime,
  ) async {
    final url = "https://$apiBasePath/bal/${balId.toString()}";
    log.i("Fetching: editBal ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders({"Content-Type": "application/json"});
      final body = {
        "name": name,
        "start_timestamp": (startTime.millisecondsSinceEpoch / 1000).round(),
        "end_timestamp": (endTime.millisecondsSinceEpoch / 1000).round(),
      };
      final response = await client.patch(
        Uri.parse(url),
        headers: headers,
        body: jsonEncode(body),
      );
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Bal.fromJSON(json));
        case 403:
          throw "You don't own the specified BAL";
        case 404:
          throw "No bal with specified id";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Gets a [Bal] from it's [balId]
  Future<Result<Bal>> getBalById(int balId) async {
    final url = "https://$apiBasePath/bal/${balId.toString()}";
    log.i("Fetching: getBalById ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Bal.fromJSON(json));
        case 403:
          throw "You don't own the specified BAL";
        case 404:
          throw "No BAL with this id found in database";
        default:
          throw "Unknown error";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Adds a [Bal] from it's [name], [startTime] and [endTime]
  Future<Result<Bal>> addBal(
    String name,
    DateTime startTime,
    DateTime endTime,
  ) async {
    final url = "https://$apiBasePath/bal";
    log.i("Fetching: addBal ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders({"Content-Type": "application/json"});
      final body = {
        "name": name,
        "start_timestamp": (startTime.millisecondsSinceEpoch / 1000).round(),
        "end_timestamp": (endTime.millisecondsSinceEpoch / 1000).round(),
      };
      final response = await client.post(
        Uri.parse(url),
        headers: headers,
        body: jsonEncode(body),
      );
      switch (response.statusCode) {
        case 201:
          final json = jsonDecode(response.body);
          return Result.ok(Bal.fromJSON(json));
        case 400:
          throw "Time cannot go backwards";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Gets a [List<Bal>] of all [Bal]
  Future<Result<List<Bal>>> getBals() async {
    final url = "https://$apiBasePath/bals";
    log.i("Fetching: getBals ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);

      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body) as List<dynamic>;
          return Result.ok(
            json.map((element) => Bal.fromJSON(element)).toList(),
          );
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Gets the ongoing BAL for the user
  Future<Result<Bal?>> getOngoingBal() async {
    final url = "https://$apiBasePath/bal/current";
    log.i("Fetching: getCurrentBal ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      if (response.statusCode == 200) {
        final json = jsonDecode(response.body);
        return Result.ok(Bal.fromJSON(json));
      } else if (response.statusCode == 404) {
        return Result.ok(null);
      } else {
        throw Exception("Something went wrong");
      }
    } catch (e) {
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /*
 * ===================
 * =====[ BOOKS ]=====
 * ===================
*/

  /// Gets a [Book] by its [bookId]
  Future<Result<Book>> getBookById(int bookId) async {
    final url = "https://$apiBasePath/book/id/${bookId.toString()}";
    log.i("Fetching: getBookById ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Book.fromJSON(json));
        case 404:
          throw "No book with this id exists in database";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception("API $e"));
    } finally {
      client.close();
    }
  }

  /// Gets a [Book] from its [ean]
  Future<Result<Book>> getBookByEAN(String ean) async {
    final url = "https://$apiBasePath/book/ean/$ean";
    log.i("Fetching: getBookByEan ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Book.fromJSON(json));
        case 404:
          throw "No book with this EAN found in the database of BNF";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception("API $e"));
    } finally {
      client.close();
    }
  }

  /*
 * =============================
 * =====[ BOOKS INSTANCES ]=====
 * =============================
*/

  /// Gets a [BookInstance] from it's [title], [author] or both
  Future<Result<List<SearchResult>>> getBookInstanceBySearch(
    int balId,
    String title,
    String author,
  ) async {
    final url = "https://$apiBasePath/bal/${balId.toString()}/search";
    log.i("Fetching: getBookInstancesBySearch ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders({"Content-Type": "application/json"});
      final body = jsonEncode({"title": title, "author": author});
      final response = await client.post(
        Uri.parse(url),
        headers: headers,
        body: body,
      );
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body) as List<dynamic>;
          return Result.ok(
            json.map((el) => SearchResult.fromJSON(el)).toList(),
          );
        case 403:
          throw "You do not own the BAL";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception("API $e"));
    } finally {
      client.close();
    }
  }

  /// Gets a [BookInstance] from it's [ean]
  Future<Result<List<BookInstance>>> getBookInstanceByEAN(
    int balId,
    int ean,
  ) async {
    final url =
        "https://$apiBasePath/bal/${balId.toString()}/ean/${ean.toString()}/book_instances";
    log.i("Fetching: getBookInstancesByEan ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body) as List<dynamic>;
          return Result.ok(
            json.map((el) => BookInstance.fromJSON(el)).toList(),
          );
        case 403:
          throw "You do not own the BAL";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception("API $e"));
    } finally {
      client.close();
    }
  }

  /// Notifies the server of the sell of multiple [BookInstance]. [books] is in the form of
  /// ```dart
  /// final books = {"aBookInstanceId": 6.0} // and its price
  /// ```
  Future<Result<void>> sellBooks(Map<String, double?> books) async {
    final url = "https://$apiBasePath/book_instance/sell/bulk";
    log.i("Fetching: sellBooks ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders({"Content-Type": "application/json"});
      final body = jsonEncode(books);
      final response = await client.post(
        Uri.parse(url),
        headers: headers,
        body: body,
      );
      switch (response.statusCode) {
        case 200:
          return Result.ok(response.statusCode);
        case 403:
          throw "You don't own one of the specified books";
        case 404:
          throw "One of the books was not found";
        case 409:
          throw "One of the books wasn't available";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Creates a new [BookInstance] from it's [book], it's [owner], it's [bal] and it's [price]
  Future<Result<BookInstance>> sendNewBookInstance(
    Book book,
    Owner owner,
    Bal bal,
    double price,
  ) async {
    final url = "https://$apiBasePath/book_instance";
    log.i("Fetching: sendBook ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders({"Content-Type": "application/json"});
      final body = jsonEncode({
        "bal_id": bal.id,
        "book_id": book.id,
        "owner_id": owner.id,
        "price": price,
      });
      final response = await client.post(
        Uri.parse(url),
        headers: headers,
        body: body,
      );
      switch (response.statusCode) {
        case 201:
          final json = jsonDecode(response.body);
          return Result.ok(BookInstance.fromJSON(json));
        case 403:
          throw "You don't own that book instance";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /*
 * ====================
 * =====[ OWNERS ]=====
 * ====================
*/

  /// Gets an [Owner] by it's [ownerId]
  Future<Result<Owner>> getOwnerById(int ownerId) async {
    final url = "https://$apiBasePath/owner/${ownerId.toString()}";
    log.i("Fetching: getOwnerById ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Owner.fromJSON(json));
        case 403:
          throw "You do not own specified owner";
        case 404:
          throw "No owner with this id exists";
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception("API $e"));
    } finally {
      client.close();
    }
  }

  /// Get the owner of the current user
  Future<Result<Owner>> getOwnerOfUser() async {
    final url = "https://$apiBasePath/owner/self";
    log.i("Fetching: getSectionOwner ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body);
          return Result.ok(Owner.fromJSON(json));
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }

  /// Get a [List<Owner>] of all [Owner]
  Future<Result<List<Owner>>> getOwners() async {
    final url = "https://$apiBasePath/owners";
    log.i("Fetching: getOwners ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders();
      final response = await client.get(Uri.parse(url), headers: headers);
      switch (response.statusCode) {
        case 200:
          final json = jsonDecode(response.body) as List<dynamic>;
          return Result.ok(
            json.map((element) => Owner.fromJSON(element)).toList(),
          );
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } on Exception catch (error) {
      return Result.error(error);
    } finally {
      client.close();
    }
  }

  /// Adds an [Owner] from its [firstName], [lastName] and [contact]
  Future<Result<Owner>> addOwner(
    String firstName,
    String lastName,
    String contact,
  ) async {
    final url = "https://$apiBasePath/owner";
    log.i("Fetching: addOwner ($url)");
    final client = Client();
    try {
      final headers = await _getHeaders({"Content-Type": "application/json"});
      final body = {
        "first_name": firstName,
        "last_name": lastName,
        "contact": contact,
      };
      final response = await client.post(
        Uri.parse(url),
        headers: headers,
        body: jsonEncode(body),
      );
      switch (response.statusCode) {
        case 201:
          final json = jsonDecode(response.body);
          return Result.ok(Owner.fromJSON(json));
        default:
          throw "Unknown error with code ${response.statusCode.toString()}";
      }
    } catch (e) {
      log.e(e.toString());
      return Result.error(Exception(e));
    } finally {
      client.close();
    }
  }
}