import 'dart:collection';

import 'package:aitrainer_app/util/app_language.dart';
import 'package:aitrainer_app/model/cache.dart';
import 'package:aitrainer_app/model/customer.dart';
import 'package:aitrainer_app/model/exercise.dart';
import 'package:aitrainer_app/model/exercise_type.dart';
import 'package:aitrainer_app/model/workout_menu_tree.dart';
import 'package:aitrainer_app/service/exercise_service.dart';
import 'package:flutter_form_bloc/flutter_form_bloc.dart';

class ExerciseRepository {
  Exercise exercise;
  Customer customer;
  ExerciseType exerciseType;
  List<Exercise> exerciseList;
  List<Exercise> exerciseLogList = List();
  List<Exercise> actualExerciseList = List();

  double rmWendler = 0;
  double rmMcglothlin = 0;
  double rmLombardi = 0;
  double rmMayhew = 0;
  double rmOconner = 0;
  double rmWathen = 0;

  DateTime start;
  DateTime end;

  ExerciseRepository() {
    this.createNew();
  }

  createNew() {
    this.exercise = Exercise();
    exercise.dateAdd = DateTime.now();
  }

  setQuantity(double quantity) {
    if (this.exercise == null) {
      this.createNew();
    }
    this.exercise.quantity = quantity;
  }

  setUnitQuantity(double unitQuantity) {
    if (this.exercise == null) {
      this.createNew();
    }

    this.exercise.unitQuantity = unitQuantity;
  }

  setUnit(String unit) {
    if (this.exercise == null) {
      this.createNew();
    }

    this.exercise.unit = unit;
  }

  setDatetimeExercise(DateTime datetimeExercise) {
    if (this.exercise == null) {
      this.createNew();
    }

    this.exercise.dateAdd = datetimeExercise;
  }

  double get unitQuantity => this.exercise.unitQuantity;

  double get quantity => this.exercise.quantity;

  Exercise getExercise() => this.exercise;

  Future<Exercise> addExercise() async {
    final Exercise modelExercise = this.exercise;
    modelExercise.customerId = this.customer.customerId;
    modelExercise.exerciseTypeId = this.exerciseType.exerciseTypeId;
    if (exerciseType.unitQuantity != "1") {
      modelExercise.unitQuantity = null;
    }

    Exercise copy = modelExercise.copy();
    this.actualExerciseList.add(copy);
    //final int index = this.actualExerciseList.length - 1;
    //print("$index. actual exercise " + this.actualExerciseList[index].toJson().toString());
    Exercise savedExercise = await ExerciseApi().addExercise(modelExercise);

    //this.actualExerciseList[index].exerciseId = savedExercise.exerciseId;
    if (customer.customerId == Cache().userLoggedIn.customerId) {
      Cache().addExercise(savedExercise);
    } else if (Cache().getTrainee() != null && customer.customerId == Cache().getTrainee().customerId) {
      Cache().addExerciseTrainee(savedExercise);
    }

    return savedExercise;
  }

  void initExercise() {
    this.createNew();
    this.exerciseType = exerciseType;
    this.setUnit(exerciseType.unit);
    exercise.exerciseTypeId = this.exerciseType.exerciseTypeId;
    this.setQuantity(12);
    this.setUnitQuantity(30);
    this.exercise.exercisePlanDetailId = 0;
    exercise.exerciseId = 0;
    this.start = DateTime.now();
  }

  Future<void> deleteExercise(Exercise exercise) async {
    await ExerciseApi().deleteExercise(exercise);
  }

  setCustomer(Customer customer) => this.customer = customer;

  setExerciseType(ExerciseType exerciseType) => this.exerciseType = exerciseType;

  Future<List<Exercise>> getExercisesByCustomer(int customerId) async {
    final results = await ExerciseApi().getExercisesByCustomer(customerId);
    this.exerciseList = results;
    if (Cache().userLoggedIn != null) {
      if (customerId == Cache().userLoggedIn.customerId) {
        Cache().setExercises(exerciseList);
      } else if (Cache().getTrainee() != null && customerId == Cache().getTrainee().customerId) {
        Cache().setExercisesTrainee(exerciseList);
      }
    }
    return this.exerciseList;
  }

  List<Exercise> getExerciseList() {
    this.exerciseList = Cache().getExercises();
    return this.exerciseList;
  }

  List<Exercise> getExerciseListTrainee() {
    this.exerciseList = Cache().getExercisesTrainee();
    return this.exerciseList;
  }

  String nextMissingBaseExercise(SplayTreeMap sortedTree) {
    if (exerciseList == null) {
      exerciseList = Cache().getExercises();
    }

    if (exerciseList == null) {
      return "";
    }
    String missingTreeName;
    String foundTreeName;
    bool isBreak = false;

    sortedTree.forEach((key, list) {
      List<WorkoutMenuTree> listByMuscle = list as List<WorkoutMenuTree>;
      String treeName = key as String;
      treeName = treeName.substring(3);
      foundTreeName = null;
      listByMuscle.forEach((exercise) {
        if (missingTreeName == null) {
          missingTreeName = treeName;
        }
        if (exercise.base) {
          exerciseList.forEach((element) {
            if (element.exerciseTypeId == exercise.exerciseTypeId) {
              foundTreeName = treeName;
              //print("Found " + foundTreeName + " Missing actual: " + missingTreeName);
              isBreak = true;
            }
          });
        }
      });
      if (foundTreeName == null && !isBreak) {
        missingTreeName = treeName;
        isBreak = true;
      }
    });

    return missingTreeName;
  }

  void getBaseExerciseFinishedPercent() {
    List<int> checkedExerciseTypeId = List();
    List<int> baseTreeItem = List();
    List<int> checkedBaseTreeItem = List();
    int count1RMExercises = 0;
    LinkedHashMap<String, WorkoutMenuTree> tree = Cache().getWorkoutMenuTree();

    if (tree == null) {
      return;
    }

    tree.forEach((key, value) {
      WorkoutMenuTree treeItem = value;
      if (treeItem.exerciseType != null && treeItem.exerciseType.base == true && !baseTreeItem.contains(treeItem.parent)) {
        baseTreeItem.add(treeItem.parent);
      }
    });

    if (exerciseList == null) {
      exerciseList = Cache().getExercises();
    }

    if (exerciseList == null) {
      return;
    }

    exerciseList.forEach((element) {
      Exercise exercise = element;
      if (!checkedExerciseTypeId.contains(exercise.exerciseTypeId)) {
        checkedExerciseTypeId.add(exercise.exerciseTypeId);
        tree.forEach((key, value) {
          WorkoutMenuTree treeItem = value;
          if (treeItem.exerciseType != null &&
              treeItem.exerciseType.base == true &&
              exercise.exerciseTypeId == treeItem.exerciseType.exerciseTypeId &&
              !checkedBaseTreeItem.contains(treeItem.parent)) {
            //print ("id: " + exercise.exerciseTypeId.toString());
            checkedBaseTreeItem.add(treeItem.parent);
            count1RMExercises++;
          }
        });
      }
    });

    //print ("checkedExerciseTypeid: " + checkedExerciseTypeId.toString());
    //print ("baseTreeItem: " + baseTreeItem.toString());
    //print ("count1RMExercises: " + count1RMExercises.toString());
    final double percent = count1RMExercises / baseTreeItem.length;
    Cache().setPercentExercises(percent);
  }

  void getLastExercise() {
    List<Exercise> exercises = this.getExerciseList();
    Exercise lastExercise = exercises[0];
    exercises.forEach((element) {
      Exercise actualExercise = element;
      if (actualExercise.dateAdd.compareTo(lastExercise.dateAdd) > 0) {
        lastExercise = actualExercise;
      }
    });
    this.exercise = lastExercise;
    this.customer = Cache().userLoggedIn;
    this.exerciseType = getExerciseTypeById(exercise.exerciseTypeId);
    return;
  }

  ExerciseType getExerciseTypeById(int exerciseTypeId) {
    ExerciseType actualExerciseType;
    Cache().getExerciseTypes().forEach((element) {
      ExerciseType exerciseType = element;
      if (exerciseType.exerciseTypeId == exerciseTypeId) {
        actualExerciseType = exerciseType;
      }
    });
    if (actualExerciseType == null) {
      throw Exception("Data error, no ExerciseType for exerciseTypeId $exerciseTypeId");
    }
    return actualExerciseType;
  }

  void getSameExercise(int exerciseTypeId, String day) {
    this.actualExerciseList = List();
    for (int i = 0; i < this.exerciseList.length; i++) {
      Exercise exercise = exerciseList[i];
      String exerciseDate = DateFormat("yyyy-MM-dd", AppLanguage().appLocal.toString()).format(exercise.dateAdd);
      if (exerciseTypeId == exercise.exerciseTypeId && exerciseDate == day) {
        this.actualExerciseList.add(exercise);
      }
    }
  }

  void sortByDate() {
    if (exerciseList.isEmpty) {
      return;
    }

    exerciseList.sort((a, b) {
      final String datePartA = DateFormat('yyyyMMdd', AppLanguage().appLocal.toString()).format(a.dateAdd);
      String aId = a.exerciseTypeId.toString() + "_" + datePartA;
      final String datePartB = DateFormat('yyyyMMdd', AppLanguage().appLocal.toString()).format(b.dateAdd);
      String bId = b.exerciseTypeId.toString() + "_" + datePartB;
      return aId.compareTo(bId);
    });

    this.exerciseLogList = List();
    String summary = "";

    String prevDate = DateFormat("yyyy-MM-dd", AppLanguage().appLocal.toString()).format(exerciseList[0].dateAdd);
    int prevExerciseTypeId = exerciseList[0].exerciseTypeId;
    Exercise prevExercise = exerciseList[0];
    int prevCount = 0;
    for (int i = 0; i < this.exerciseList.length; i++) {
      Exercise exercise = exerciseList[i];
      int exerciseTypeId = exercise.exerciseTypeId;
      String exerciseDate = DateFormat("yyyy-MM-dd", AppLanguage().appLocal.toString()).format(exercise.dateAdd);
      print(" -- $prevExerciseTypeId - '$prevDate' against $exerciseTypeId - '$exerciseDate'");
      if (exerciseTypeId != prevExerciseTypeId || prevDate != exerciseDate) {
        ExerciseType exerciseType = Cache().getExerciseTypeById(prevExercise.exerciseTypeId);
        String unit = exerciseType.unitQuantityUnit != null ? exerciseType.unitQuantityUnit : prevExercise.unit;
        prevExercise.summary = summary + " " + unit;
        exerciseLogList.add(prevExercise);
        //print("Log add " + exercise.toJson().toString());
        summary = "";
        prevCount = 0;
      }
      String delimiter = "";
      if (prevCount > 0) delimiter = ", ";
      double quantity = exercise.quantity == null ? 0 : exercise.quantity;
      summary += delimiter + quantity.toStringAsFixed(0);
      ExerciseType exerciseType = Cache().getExerciseTypeById(exercise.exerciseTypeId);
      print("exerciseType " + (exerciseType == null ? "NULL" : exerciseType.name) + " ID " + exercise.exerciseTypeId.toString());
      if (exerciseType.unitQuantity == "1") {
        summary += "x" + exercise.unitQuantity.toStringAsFixed(0);
      }
      print(" --- sum  " + exerciseType.name + " $summary");

      prevExerciseTypeId = exerciseTypeId;
      prevDate = exerciseDate;
      prevExercise = exercise;
      prevCount++;
    }
    prevExercise.summary = summary;
    exerciseLogList.add(prevExercise);
  }
}