import 'dart:collection';
import 'dart:convert';
import 'package:aitrainer_app/model/customer.dart';
import 'package:aitrainer_app/model/customer_property.dart';
import 'package:aitrainer_app/model/property.dart';
import 'package:aitrainer_app/model/user.dart';
import 'package:aitrainer_app/service/api.dart';
import 'package:aitrainer_app/model/cache.dart';
import 'package:aitrainer_app/service/logging.dart';
import 'package:aitrainer_app/util/not_found_exception.dart';

class CustomerApi with Logging {
  final APIClient _client = new APIClient();

  Future<List<Customer>> getRealCustomers(String param) async {
    final body = await _client.get("customers/", param);
    final Iterable json = jsonDecode(body);
    final List<Customer> customers = json.map((customer) => Customer.fromJson(customer)).toList();

    return customers;
  }

  Future<void> saveCustomer(Customer customer) async {
    customer.dateChange = DateTime.now();
    String body = JsonEncoder().convert(customer.toJson());
    log(" ===== saving customer id: " + customer.customerId.toString() + ":" + body);
    await _client.post("customers/" + customer.customerId.toString(), body);
  }

  Future<void> updateFirebaseUid(int customerId, String uid) async {
    log(" ===== update Firebase uid : " + customerId.toString() + ": " + uid);
    await _client.post("customers/update_firebase_uid/" + customerId.toString(), uid);
  }

  Future<void> addCustomer(Customer customer) async {
    customer.dateAdd = DateTime.now();
    customer.dateChange = DateTime.now();
    String body = JsonEncoder().convert(customer.toJson());
    log(" ===== add new customer: " + body);
    await _client.post("customers", body);
  }

  Future<void> addUser(User user) async {
    String body = JsonEncoder().convert(user.toJson());
    log(" ===== add new user: " + body);
    final String responseBody = await _client.post("registration", body);
    Customer customer;
    try {
      int status = jsonDecode(responseBody)['status'];
      if (status != null) {
        String error = jsonDecode(responseBody)['error'];
        throw new Exception(error);
      } else {
        customer = Customer.fromJson(jsonDecode(responseBody));
        await Cache().afterRegistration(customer);
      }
    } on FormatException {
      if (responseBody == "Customer exists") {
        throw WorkoutTestException(code: WorkoutTestException.CUSTOMER_EXISTS, message: responseBody);
      }
      throw new Exception(responseBody);
    }
  }

  Future<void> getUser(User user) async {
    String body = JsonEncoder().convert(user.toJson());
    log(" ===== login the user: " + body);
    final String responseBody = await _client.post("login", body);
    Customer customer;
    try {
      customer = Customer.fromJson(jsonDecode(responseBody));
      await Cache().afterLogin(customer);
    } on FormatException {
      throw new Exception(responseBody);
    }
  }

  Future<void> getUserByEmail(String email) async {
    log(" ===== User getByEmail : " + email);
    final String responseBody = await _client.get("customers/find_by_email/" + email, "");
    Customer customer;
    try {
      customer = Customer.fromJson(jsonDecode(responseBody));
      if (customer.firebaseUid == null) {
        await this.updateFirebaseUid(customer.customerId, Cache().firebaseUid);
      }
      Cache().userLoggedIn = customer;
      final List properties = await this.getActualProperties(customer.customerId);
      if (properties != null) {
        this.initProperties(properties);
      }
    } on FormatException {
      throw new Exception(responseBody);
    }
  }

  Future<void> getCustomer(int customerId) async {
    String body = "";
    log(" ===== get the customer by id: " + customerId.toString());
    try {
      final String responseBody = await _client.get("customers/" + customerId.toString(), body);
      Customer customer = Customer.fromJson(jsonDecode(responseBody));
      log(" --- Customer: " + customer.toJson().toString());
      Cache().userLoggedIn = customer;
      final List properties = await this.getActualProperties(customerId);
      //log(" ---- Props: " + properties.toJson().toString());
      //await Cache().initCustomer(customerId);
      if (properties != null) {
        this.initProperties(properties);
      }
    } on Exception catch (exception) {
      log("Exception: " + exception.toString());
      log(" === go to registration ");
      Cache().logout();
      Cache().startPage = "registration";
    }
  }

  void initProperties(final List<CustomerProperty> customerProperties) {
    List<Property> properties = Cache().getProperties();
    Customer customer = Cache().userLoggedIn;
    customer.properties = LinkedHashMap<String, CustomerProperty>();

    // reset Properties
    properties.forEach((property) {
      CustomerProperty customerProperty =
          CustomerProperty(propertyId: property.propertyId, customerId: customer.customerId, dateAdd: null, propertyValue: 0);
      customer.properties[property.propertyName] = customerProperty;
    });

    customerProperties.forEach((customerProperty) {
      properties.forEach((property) {
        if (customerProperty.propertyId == property.propertyId) {
          customer.properties[property.propertyName] = customerProperty;
        }
      });
    });
  }

  Future<Customer> getTrainee(int customerId) async {
    String body = "";
    Customer customer;
    log(" ===== get Trainee customer by id: " + customerId.toString());
    try {
      final String responseBody = await _client.get("customers/" + customerId.toString(), body);
      customer = Customer.fromJson(jsonDecode(responseBody));
      log(" --- Trainee: " + customer.toJson().toString());
    } catch (exception) {
      log("Exception: " + exception.toString());
      throw Exception(exception);
    }
    return customer;
  }

  Future<List<Customer>> getTrainees(int trainerId) async {
    List<Customer> trainees = List<Customer>();
    log("Get trainees list");
    try {
      String body = "";
      final String responseBody = await _client.get("customers/trainees/" + trainerId.toString(), body);
      final Iterable json = jsonDecode(responseBody);
      trainees = json.map((customer) => Customer.fromJson(customer)).toList();
    } catch (exception) {
      log("Exception: " + exception.toString());
      throw Exception(exception);
    }
    return trainees;
  }

  Future<List<CustomerProperty>> getAllProperties(int customerId) async {
    final body = await _client.get("customer_property/", customerId.toString());
    final Iterable json = jsonDecode(body);
    final List<CustomerProperty> properties = json.map((property) => CustomerProperty.fromJson(property)).toList();

    return properties;
  }

  Future<List<CustomerProperty>> getActualProperties(int customerId) async {
    List<CustomerProperty> properties;
    try {
      final body = await _client.get("customer_property/last/", customerId.toString());
      final Iterable json = jsonDecode(body);
      properties = json.map((property) => CustomerProperty.fromJson(property)).toList();

      if (properties != null) {
        properties.forEach((element) {
          //log("Property " + element.toString());
        });
      }
    } on Exception catch (ex) {
      log(ex.toString());
    }
    return properties;
  }

  Future<CustomerProperty> addProperty(CustomerProperty property) async {
    String body = JsonEncoder().convert(property.toJson());
    log(" ===== add new customer property: " + body);
    CustomerProperty customerProperty;
    String responseBody;
    try {
      responseBody = await _client.post("customer_property", body);
      log(" responseBody: " + responseBody);
      int status = jsonDecode(responseBody)['status'];
      if (status != null) {
        throw new Exception(jsonDecode(responseBody)['error']);
      } else {
        customerProperty = CustomerProperty.fromJson(jsonDecode(responseBody));
        if (customerProperty == null) {
          throw new Exception("Property Insert was not successful");
        }
      }
    } on FormatException {
      throw new Exception(responseBody);
    } on Exception catch (e) {
      throw new Exception(e);
    }
    return customerProperty;
  }

  Future<CustomerProperty> updateProperty(CustomerProperty property) async {
    String body = JsonEncoder().convert(property.toJson());
    CustomerProperty customerProperty;
    log(" ===== update customer property: " + body);
    String responseBody;
    try {
      responseBody = await _client.post("customer_property/update/" + property.customerPropertyId.toString(), body);
      log(" responseBody: " + responseBody);
      int status = jsonDecode(responseBody)['status'];
      if (status != null) {
        throw new Exception(jsonDecode(responseBody)['error']);
      } else {
        customerProperty = CustomerProperty.fromJson(jsonDecode(responseBody));
        if (customerProperty == null) {
          throw new Exception("Property Update was not successful");
        }
      }
    } on FormatException {
      throw new Exception(responseBody);
    } on Exception catch (e) {
      throw new Exception(e);
    }
    return customerProperty;
  }
}