Controller.java

import User.*;
import Activity.*;
import TrainingPlan.TrainingPlan;
import Simulation.Tempo;

import java.util.ArrayList;
import java.util.List;
import java.io.*;
import java.time.Duration;
import java.time.LocalDateTime;
import Status.Status;


public class Controller {
    List <User> model;
    private User currentUser;
    private Tempo tempo;
    private Status status;

    
    public Controller(){
        this.currentUser = null;
        this.model = new ArrayList<User>();
        this.tempo = new Tempo();
        this.status = new Status();
    }

    // Check if the username is available for registration
    public boolean isUsernameAvailable(String username) {
        load();
        for (User u : this.model) {
            if (u.getUsername().equals(username)) {
                return false;
            }
        }
        return true;
    }

    public boolean isEmailAvailable(String email) {
        load();
        for (User u : this.model) {
            if (u.getEmail().equals(email)) {
                return false;
            }
        }
        return true;
    }

    public void SignUp(String username, String password, String email, double height, double weight, double heartRate, String address, int age, int userType){
        load();
        User user = null;
        switch (userType) {
            case 1:
                user = new PraticanteOcasional(username, password, email, height, weight, heartRate, address, age);
                break;
            case 2:
                user = new Profissional(username, password, email, height, weight, heartRate, address, age);
                break;
            case 3:
                user = new Amador(username, password, email, height, weight, heartRate, address, age);
                break;
            default:
                break;
        }

        for (User u : this.model) {
            if (u.getUsername().equals(user.getUsername())) {
                System.out.println("User already exists");
                return;
            } else if (u.getEmail().equals(user.getEmail())) {
                System.out.println("Email already exists");
                return;
            }
        }
        
        this.model.add(user);
        save();
    }

    public boolean SignIn(String username, String password){
        load();
        for (User u : this.model) {
            if (u.getUsername().equals(username)) {
                if (u.getPassword().equals(password)) { 
                    this.currentUser = u; // Set the currently logged-in user
                    return true;
                } 
            }
        }
        return false;
    }

    public void SignOut(){         // atualizar o pointer para o user vazio
        this.currentUser = null;
    }

    public String userLoginName(){
        if (this.currentUser != null) {
            return this.currentUser.getUsername();
        } else {
            return "No user logged in";
        }
    }

/*     public void removeUser(String username){
        for (User u : this.model) {
            if (u.getUsername().equals(username)) {
                this.model.remove(u);
                return;
            }
        }
        System.out.println("User not found");
    } */

    public Tempo getTempo(){
        return tempo;
    }

    // Return um clone the list of users 
    public List<User> getUsers(){
        load();
        List <User> users = new ArrayList<>();
        for (User user : this.model) {
            users.add(user);
        }
        return users;
    }

    public void addActivity(Activity activity) {
        this.save();
        this.currentUser.addActivity(activity);
        this.save();
    }

    public List<Activity> getActivitiesCurrentUser() {
        load();
        return this.currentUser.getArrayActivities();
    }

    public void addTrainingPlan(TrainingPlan trainingPlan) {
        this.save();
        this.currentUser.addTrainingPlan(trainingPlan);
        this.save();
    }

    public List<TrainingPlan> getTrainingPlansCurrentUser() {
        load();
        return this.currentUser.getTrainingPlans();
    }

    public void printActivities() {
        load();
        for (Activity a : getActivitiesCurrentUser()) {
            System.out.println(" {\n" + a + "\nStatus: " + (a.isInProgress(this.tempo.getCurrentTime()) ? "In progress" : a.isDone(this.tempo.getCurrentTime()) ? "Done" : "Not started") + "\n},");
        }
    }


    public void save() {
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("users.ser"))) {
            out.writeObject(model);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void saveTempo() {
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("simulation.ser"))) {
            out.writeObject(tempo);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void load() {
        File fileUsers = new File("users.ser");
        if (fileUsers.exists()) {
            try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileUsers))) {
                model = (ArrayList<User>) in.readObject();
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        } else {
            model = new ArrayList<>();
        }
    }

    public void loadTempo() {
        File fileTime = new File("simulation.ser");
        if (fileTime.exists()) {
            try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileTime))) {
                tempo = (Tempo) in.readObject();
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        } else {
            tempo = new Tempo();
        }
    }

    public void DeleteSaveData() {
        try {
            File file = new File("users.ser");
            if (file.delete()) {
                System.out.println("Users file deleted successfully");
            } else {
                System.out.println("Failed to delete the users file");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void deleteTempo() {
        try {
            File file = new File("simulation.ser");
            if (file.delete()) {
                System.out.println("Simulation file deleted successfully");
            } else {
                System.out.println("Failed to delete the simulation file");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    public void createDistanceActivity(String name, int duration, boolean isHard, double distance, int ActivityType_1, LocalDateTime date, String trainingPlan) {
        Activity activity = null;

        switch (ActivityType_1) {
            case 1:
                activity = new Corrida_atletismo(name, duration, distance, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_1 = activity.CalculateCalories();
                activity.setCalories(calorias_1);
                break;
            case 2:
                activity =  new Remo(name, duration, distance, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_2 = activity.CalculateCalories();
                activity.setCalories(calorias_2);
                break;
            case 3:
                activity = new Patinagem(name, duration, distance, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_3 = activity.CalculateCalories();
                activity.setCalories(calorias_3);
                break;
            default:
                break;
        }

        if (activity != null) {
            if (trainingPlan != null) {
                TrainingPlan plan = getTrainingPlanByName(trainingPlan);

                if (plan == null) {
                    createTrainingPlan(trainingPlan);
                    plan = getTrainingPlanByName(trainingPlan);
                }

                plan.addActivityToPlan(activity);
                this.addTrainingPlan(plan);
                
            } else {
                this.addActivity(activity);
                
            }
        }
    }

    public void createAltimetryActivity(String name, int duration, boolean isHard, double distance, double altimetry, int ActivityType_2, LocalDateTime date, String trainingPlan) {
        Activity activity = null;

        switch (ActivityType_2) {
            case 1:
                activity = new Bicicleta_estrada(name, duration, distance, altimetry, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_4 = activity.CalculateCalories();
                activity.setCalories(calorias_4);
                break;
            case 2:
                activity =  new Bicicleta_montanha(name, duration, distance, altimetry, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_5 = activity.CalculateCalories();
                activity.setCalories(calorias_5);
                break;
            case 3:
                activity = new Corrida_estrada(name, duration, distance, altimetry, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_6 = activity.CalculateCalories();
                activity.setCalories(calorias_6);
                break;
            case 4: 
                activity = new Trail_monte(name, duration, distance, altimetry, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_7 = activity.CalculateCalories();
                activity.setCalories(calorias_7);
                break;
            default:
                break;
        }

        if (activity != null) {
            if (trainingPlan != null) {
                TrainingPlan plan = getTrainingPlanByName(trainingPlan);

                if (plan == null) {
                    createTrainingPlan(trainingPlan);
                    plan = getTrainingPlanByName(trainingPlan);
                }

                plan.addActivityToPlan(activity);
                this.addTrainingPlan(plan);
            } else {
                this.addActivity(activity);
            }
        }
    }

    public void createRepetitionActivity(String name, int duration, boolean isHard, int repetitions, int sets, int ActivityType_3, LocalDateTime date, String trainingPlan) {
        Activity activity = null;

        switch (ActivityType_3) {
            case 1:
                activity = new Abdominais(name, duration, repetitions, sets, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_8 = activity.CalculateCalories();
                activity.setCalories(calorias_8);
                break;
            case 2:
                activity =  new Flexoes(name, duration, repetitions, sets, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_9 = activity.CalculateCalories();
                activity.setCalories(calorias_9);
                break;
            case 3:
                activity = new Alongamentos(name, duration, repetitions, sets, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_10 = activity.CalculateCalories();
                activity.setCalories(calorias_10);
                break;
            case 4:
                activity = new Muscle_up(name, duration, repetitions, sets, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_11 = activity.CalculateCalories();
                activity.setCalories(calorias_11);
                break;
            default:
                break;
        }

        if (activity != null) {
            if (trainingPlan != null) {
                TrainingPlan plan = getTrainingPlanByName(trainingPlan);

                if (plan == null) {
                    createTrainingPlan(trainingPlan);
                    plan = getTrainingPlanByName(trainingPlan);
                }

                plan.addActivityToPlan(activity);
                this.addTrainingPlan(plan);
            } else {
                this.addActivity(activity);
            }
        }
    }

    public void createWeightActivity( String name, int duration, boolean isHard, int repetition,int sets, double weight, int ActivityType_4, LocalDateTime date, String trainingPlan) {
        Activity activity = null;

        switch (ActivityType_4) {
            case 1:
                activity = new Levantamento_pesos(name, duration, repetition, sets, weight, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_12 = activity.CalculateCalories();
                activity.setCalories(calorias_12);
                break;
            case 2:
                activity =  new Extensao_pernas(name, duration, repetition, sets, weight, currentUser.getWeight(), currentUser.getHeartRate(), currentUser.getHeight(), currentUser.getAge(), UserCalorieFactor(currentUser), date);
                int calorias_13 = activity.CalculateCalories();
                activity.setCalories(calorias_13);
                break;
            default:
                break;
        }

        if (activity != null) {
            if (trainingPlan != null) {
                TrainingPlan plan = getTrainingPlanByName(trainingPlan);

                if (plan == null) {
                    createTrainingPlan(trainingPlan);
                    plan = getTrainingPlanByName(trainingPlan);
                }

                plan.addActivityToPlan(activity);
                this.addTrainingPlan(plan);
            } else {
                this.addActivity(activity);
            }
        }
    }

    public void printTrainingPlans() {
        for (TrainingPlan plan : this.currentUser.getTrainingPlans()) {
            System.out.println("Plano de Treino: " + plan.getName() + "\nNº de atividades: " + plan.getPlan().size());
            for (Activity a : plan.getPlan()) {
                System.out.println(a.getName() + " - " +  a.getCalories() + " calorias - " + a.getDuration() + " minutos");
            }
            System.out.println();
        }
    }

    public void createTrainingPlan(String name) {
        TrainingPlan trainingPlan = new TrainingPlan();
        trainingPlan.setName(name);
        trainingPlan.setPlan(new ArrayList<Activity>());
        this.currentUser.addTrainingPlan(trainingPlan);
    }

    public TrainingPlan getTrainingPlanByName(String name) {
        for (TrainingPlan trainingPlan : this.currentUser.getTrainingPlans()) {
            if (trainingPlan.getName().equals(name)) {
                return new TrainingPlan(trainingPlan.getName(), trainingPlan.getPlan());
            }
        }
        return null;
    }

    public double UserCalorieFactor(User currentUser) {
        if(currentUser instanceof PraticanteOcasional){
            return ((PraticanteOcasional) currentUser).getCalorieFactor();
        }
        if(currentUser instanceof Amador){
            return ((Amador) currentUser).getCalorieFactor();
        }
        return ((Profissional) currentUser).getCalorieFactor();
    }

    public void avancarXMinutos(int minutos) {
        this.tempo.addTime(minutos);
    }

    public void voltarXMinutos(int minutos) {
        this.tempo.decreaseTime(minutos);
    }

    public void avancarXHoras(int horas) {
        this.tempo.addTime(horas, 0);
    }

    public void voltarXHoras(int horas) {
        this.tempo.decreaseTime(horas, 0);
    }

    public void avancarXDias(int dias) {
        this.tempo.addTime(dias, 0, 0);
    }

    public void voltarXDias(int dias) {
        this.tempo.decreaseTime(dias, 0, 0);
    }

    public void resetTime() {
        deleteTempo();
        this.tempo = new Tempo();
        saveTempo();
    }







    
    //////////////////////////////   Status    ////////////////////////////////////

    public String MostPerformedActivity() {
        load();
        return this.status.mostPerformedActivity(getUsers(), this.tempo.getCurrentTime());
    } 

    public String KmsUser() {
        return this.status.totalKms(getActivitiesCurrentUser(), this.tempo.getCurrentTime());
    }

   public String KmsUserInterval(LocalDateTime tmp1, LocalDateTime tmp2){
        return this.status.totalKmsInterval(getActivitiesCurrentUser(), this.tempo.getCurrentTime(), tmp1, tmp2);
   }

    public String AltimetryUser() {
        return this.status.totalAltimetry(getActivitiesCurrentUser(), this.tempo.getCurrentTime());
    }

    public String AltimetryUserInterval(LocalDateTime tmp3, LocalDateTime tmp4) {
        double totalAltimetry = 0;
        for (Activity a : getActivitiesCurrentUser()) {

            LocalDateTime tempo_1 = a.getDate().plus(Duration.ofMinutes(a.getDuration()));

            if (a.isDone(this.tempo.getCurrentTime()) && (a instanceof Altimetry) && tempo_1.isBefore(tmp4) && a.getDate().isAfter(tmp3)){
                totalAltimetry += this.status.UserAltimetry(a);
            }
        }
        return "Total de altimetria percorrida: " + totalAltimetry;
    }

    ///////////////////////////////// AltimetryInterval /////////

    ///////////////////////////////// Plano com maior gasto calórico /////////

    public String userMostCaloriesOfTrainingPlan() {
        TrainingPlan maxCaloriePlan = null;
        int maxCalories = 0;
    
        for (User u : getUsers()) {
            for (TrainingPlan plan : u.getTrainingPlans()) {
                int totalCalories = 0;
                for (Activity a : plan.getPlan()) {
                    totalCalories += a.getCalories();
                }

                if (totalCalories > maxCalories) {
                    maxCalories = totalCalories;
                    maxCaloriePlan = plan;
                }
            }
        }
    
        // Build the result string
        StringBuilder result = new StringBuilder();
        if (maxCaloriePlan != null) {
            result.append("Plano com maior gasto calórico: ")
                  .append(maxCaloriePlan.getName())
                  .append(" com ")
                  .append(maxCalories)
                  .append(" calorias");
        } else {
            result.append("Nenhum plano encontrado.");
        }

        return result.toString();
    }

    ///////////////////////////////// Plano com maior gasto calórico /////////

    //////////////////////////// Usuário que mais atividades realizou ////////

    public String userMostActivity() {
        load();
        return this.status.mostActivity(getUsers(),this.tempo.getCurrentTime());
    }

    
    public String userMostActivityInterval(LocalDateTime tmp5, LocalDateTime tmp6) {
       load();
       return this.status.mostActivityInterval(getUsers(), this.tempo.getCurrentTime(), tmp5, tmp6);
    }    

    public String userMostCalories() {
        load();
        return this.status.mostCalories(getUsers(),this.tempo.getCurrentTime());
    }

    public String userMostCaloriesInterval(LocalDateTime tmp7, LocalDateTime tmp8) {
        load();
        return this.status.mostActivityInterval(getUsers(),this.tempo.getCurrentTime(), tmp7,tmp8);
    }       
}