MainMenu.java

import java.util.*;
import java.io.*;

import org.json.JSONArray;
import org.json.JSONObject;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.File;
import java.io.BufferedReader;
import java.io.IOException;





public class MainMenu {
    static Scanner sc = new Scanner(System.in);// sets scanner for user input for the menu
    static ArrayList<HashMap<String, String>> logs = new ArrayList<>();//used to store the log entries
    static final String FILE_NAME = "log.json"; //Log file name


    public static void main(String[] args) {

        loadLogsFromFile(); // loads the logs from previously saved file on startup

        while(true) {//continuous loop
            System.out.println("\n--- Emotional Wellness Tracker ---");//menu line output
            System.out.println("1. Log Feelings");
            System.out.println("2. View Logs");
            System.out.println("3. View Emotional Wellness");
            System.out.println("4. Exit");
            System.out.print("Please Enter your choice: ");
            int choice = getUserInput();

            if(choice == 1) {
                logFeelings();
            }
            else if(choice == 2) {
                viewLogs();
            }
            else if(choice == 3) {
                viewEmotionalWellness();
            }
            else if(choice == 4) {
                saveLogsToFile();//saves logs to json file
                System.out.println("Program finished.");
                System.out.println("\n--- Emotional Wellness Tracker ---");
                break;//if user enters 4, program ends.
            }else{
                System.out.println("Invalid choice. Please Try again and input a valid option.");
            }
        }
    }
    /**
     *  function to Log Feelings from user
     */
    public static void logFeelings() {
        System.out.println("\n ---- Log your Feelings :) ---");//menu line output
        System.out.print("Enter your Feelings: ");//menu line output
        String feelings = sc.nextLine();//scanner stores the string of text user inputs on how they're feeling
        int sentimentScore;
        while(true) {
            System.out.println("Rate your mood today (1-10, where 10 is the happiest level)");//menu line output
            sentimentScore = getUserInput();//stores the sentimentScore that the user was feeling
            if(sentimentScore>=1 && sentimentScore<=10) {//if the sentimentScore is between 1 and 10
                break;//end the while loop
            }
            System.out.println("Invalid rating. Please enter a number between 1 and 10.");//else the program continues to ask for valid input
        }


        HashMap<String, String> logEntry = new HashMap<>();//Hashmap initialization
        logEntry.put("log", feelings);
        logEntry.put("logDate", java.time.LocalDate.now().toString());//stores the date of the log entry
        logEntry.put("logTime", java.time.LocalTime.now().toString());//stores local time of feeling log
        logEntry.put("sentimentScore",String.valueOf(sentimentScore));//stores the int to string value in the logEntry hashmap
        logs.add(logEntry);
        System.out.println("Log Feelings successfully added.");
    }
    /**
     * function that views entries of Logs of users
     */
    public static void viewLogs() {
        if(logs.isEmpty()) {//if there are no log entries available
            System.out.println("There are no log entries of feelings to view.");//menu line output
            return;

        }
        System.out.println("\n ---Emotional Wellness Tracker ---");//menu line output
        for(HashMap<String, String> logEntry : logs) {
            System.out.println("Date: " + logEntry.get("logDate") + " |Mood: " + logEntry.get("sentimentScore"));//gets the date of the log entry and the sentimentScore the user input
            System.out.println("Log of Feelings: " + logEntry.get("log"));//prints out the feeling input the user put at first
            System.out.println("------------End of Log for the Date: " +logEntry.get("logDate") + " at the time of: "+logEntry.get("logTime") +"------------");
        }
    }

    /**
     * function to view a users emotional wellness, basically has multiple(8) functions within each(submenu) and a user can input numbers to select a specific
     * emotion tracking.
     */
    public static void viewEmotionalWellness() {
        while(true){
            //System sub menu options
            System.out.println("\n ---Emotional Wellness Sub-Tracker ---");
            System.out.println("Enter a number to view the sub-function listed");
            System.out.println("1. View your most positive days");
            System.out.println("2. View your most negative days");
            System.out.println("3. View your total positive entries");
            System.out.println("4.View your total negative entries");
            System.out.println("5.View your average sentiment score");
            System.out.println("6. View your highest mood improvement");
            System.out.println("7.View your longest positive streak of days");
            System.out.println("8.View your oldest entry in the log");
            System.out.println("9. Exit");
            System.out.print("Please Enter your choice: ");

           int choice = getUserInput();//calls helper function to obtain input

            //if else statements which call on sub-functions depending on user input.
            if(choice == 1) {
                List<HashMap<String, String>> results = mostPositiveDays();
                for(HashMap<String, String> logEntry : results) {
                    System.out.println("\nDate: " + logEntry.get("logDate") +
                            " Time: " + logEntry.get("logTime") +
                            " | Positive Mood for that day: " + logEntry.get("sentimentScore") +
                            " | Feelings for that day: " + logEntry.get("log"));
                }
            }else if(choice == 2) {
                List<HashMap<String,String>> results = mostNegativeDays();
                for(HashMap<String, String> logEntry : results) {
                    System.out.println("\nDate: " + logEntry.get("logDate") +
                            " Time: " + logEntry.get("logTime") +
                            " | Negative Mood for that day: " + logEntry.get("sentimentScore") +
                            " | Feelings for that day: " + logEntry.get("log"));
                }
            }else if(choice == 3) {
                totalPositiveEntries();
            }else if(choice == 4) {
                totalNegativeEntries();
            }else if(choice == 5) {
                averageSentimentScore();
            }else if(choice == 6) {
                highestMoodImprovement();
            }else if(choice == 7) {
                longestPositiveStreak();
            }else if(choice == 8) {
                oldestLogEntry();
            }else if(choice == 9) {
                break;
            }
        }
    }

    /**
     * function to view a users emotional wellness, basically has multiple(8) functions within each(submenu) and a user can input numbers to select a specific
     * emotion tracking.
     */
     public static float averageSentimentScore() {
        int numOfScores = logs.size();
        float totalScores = 0;

        //iterate over sentiment scores
        for (HashMap<String, String> logEntry : logs) {
            totalScores += Float.parseFloat(logEntry.get("sentimentScore"));
        }

        //find average
        float avgScore = totalScores;
        avgScore /= numOfScores;

        return avgScore; //need to format
    }

    /**
     * function to save the logged feelings from logFeelings() to the log.json file
     */
    public static void saveLogsToFile() {
        //create json array
        JSONArray jsonlogs = new JSONArray();

        //create json object for each hashmap
        for (HashMap<String, String> logEntry : logs) {
            JSONObject jsonLog = new JSONObject();
            jsonLog.put("log", logEntry.get("log"));
            jsonLog.put("logDate", logEntry.get("logDate"));
            jsonLog.put("logTime", logEntry.get("logTime"));
            jsonLog.put("sentimentScore", logEntry.get("sentimentScore"));
            jsonlogs.put(jsonLog);
        }

        //write the json file
        try (FileWriter file = new FileWriter(FILE_NAME)) {

            file.write(jsonlogs.toString());
            file.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * uses I/O to get previously saved Logs
     */
    public static void loadLogsFromFile() {

        //check if no file
        File f = new File(FILE_NAME);
        if (!(f.exists() && !f.isDirectory())) {
            saveLogsToFile();
        }

        else {
            //create new file
            try (FileReader file = new FileReader(FILE_NAME)) {
                BufferedReader reader = new BufferedReader(file);

                //read file into string
                String jsonString = "";
                String line = reader.readLine();
                while (line != null) {
                    jsonString += line;
                    line = reader.readLine();
                }
                reader.close();

                //turn string into json array
                JSONArray jsonlogs = new JSONArray(jsonString);

                //create hashmaps for each json object
                for (int i = 0; i < jsonlogs.length(); i++) {
                    HashMap<String, String> logEntry = new HashMap<>();
                    JSONObject jsonLog = jsonlogs.getJSONObject(i);
                    logEntry.put("log", jsonLog.getString("log"));
                    logEntry.put("logDate", jsonLog.getString("logDate"));
                    logEntry.put("logTime", jsonLog.getString("logTime"));
                    logEntry.put("sentimentScore", jsonLog.getString("sentimentScore"));
                    logs.add(logEntry); //add hasmap to logs array
                }

            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    /** function to grab UserInput and avoid user inputting wrong data Type
     * gives them a set number of valid attempts so there's no infinite loop
     *
     * @return returns the VALID choice the user inputs, if they get it within the max amount of attempts
     */
   public static int getUserInput(){
        int choice = -1;//def choice
        int attempts = 0;
        int MaxAttempts = 5;
        while(attempts < MaxAttempts) {
            try{
                choice = sc.nextInt();//gets user input
                sc.nextLine();//clears the buffer
                return choice; //exit if input is invalid

            }catch (InputMismatchException e){
                System.out.println("Invalid input. Please try again.");
                sc.nextLine();//Clears the invalid input
                attempts++; //increments values
            }
        }
        return -1;//returns -1 if input is invalid
   }


    /**
     * function that sorts sentiment scores, and outputs the most positive days stored in the log (sentiment scores from 6-10)
     * @return list of top 5 positive log entries
     */
    public static List<HashMap<String, String>> mostPositiveDays() {
        List<HashMap<String, String>> sortedLogs = new ArrayList<>(); // creates a new list for storing logs
        // filters log entries from scores 6-10
        for (HashMap<String, String> logEntry : logs) { // for every entry in logs
            String scoreString = logEntry.get("sentimentScore"); // gets the sentiment score from the key
            if (scoreString != null && !scoreString.isEmpty()) { // if that key does exist
                int score = Integer.parseInt(scoreString); // parses the key(score) from string to int
                if (score >= 6) { // if score is greater than or equal to 6
                    sortedLogs.add(logEntry); // add to sortedLogs
                }
            } else {
                System.out.println("Sentiment score is empty. Please try again."); // if key does not exist
            }
        }
        // sorting of orders for positive sentiment scores in descending order
        // uses comparator inbuilt function
        // uses lambda expression as log1 and log2 are elements of sortedLogs and compares them
        // the order of log2 before log1 ensures that it is in descending (log1 before log2 = ascending)
        sortedLogs.sort((log1, log2) -> Integer.compare(Integer.parseInt(log2.get("sentimentScore")), Integer.parseInt(log1.get("sentimentScore"))));
        //returns sublist(a portion of the sortedLogs list(only the top 5)
        return sortedLogs.subList(0, Math.min(5, sortedLogs.size())); // return top 5 entries
    }

    /**
     * function that sorts sentiment scores, and outputs the most negative days stored in the log.(sentiment scores from 1-4)(5 being neutral)
     * @return List of top 5 neg Log entries
     */
    public static List<HashMap<String, String>> mostNegativeDays() {
        List<HashMap<String, String>> sortedNegLogs = new ArrayList<>(); // creates a new list for storing logs
        for (HashMap<String, String> logEntry : logs) { // for every entry in logs
            String scoreString = logEntry.get("sentimentScore"); // gets the sentiment score from the key
            if (scoreString != null && !scoreString.isEmpty()) { // if that key does exist
                int score = Integer.parseInt(scoreString); // parses the key(score) from string to an int
                if (score <= 4) { // if the score is less than or equal to 4
                    sortedNegLogs.add(logEntry); // adds to negativeLogs
                }
            } else {
                System.out.println("Sentiment score is empty. Please try again."); // if key does not exist
            }
        }
        // sorts new list of negative log entries in ascending order (starting with least happy day)
        sortedNegLogs.sort(Comparator.comparingInt(log -> Integer.parseInt(log.get("sentimentScore"))));
        //returns sublist(a portion of the sortedNegLogs list(only the top 5)
        return sortedNegLogs.subList(0, Math.min(5, sortedNegLogs.size())); // return top 5 entries
    }


    public static void totalNegativeEntries(){}

    public static void totalPositiveEntries(){}

    public static void longestPositiveStreak(){}

    public static void highestMoodImprovement(){}

    public static void oldestLogEntry(){}
}