+
+**Main Components of LifeTracker**
+
+`LifeTracker` is where users will access the application from. It is responsible for:
+
+- At app launch: Initialise the Databases and UI classes
+- At app closure: Saves all updated data to databases
+
+The rest of the Application consists of three components:
+
+- `UI`: Reponsible for I/O between user and application
+- `Command`: Handles execution of user inputs
+- `Storage`: Stores information of the user and meals eaten
+
+---
+
+### UI Component
+
+API: ui.java
+
+
+
+The UI is made up of five classes, `GeneralUi`, `CalorieUi`, `ExampleUi`, `ExerciseUi` and `WeightUi`, and together,
+they improve on the accessibility of the application.
+
+The `UI` component,
+
+- Displays what are the possible inputs at any one time
+- Allows the user to check that a value added is correct
+- Informs the user whenever there is an invalid input
+
+### Command Component
+
+API: commands.java
+
+
+
+How the `Command` component works:
+
+1. When a user first enters something into the CLI, the `CommandParser` subclass from the `Parser` class is used to parse the user command.
+2. Based on the results of the parsing, a specific command object is created (e.g. `AddMealCommand`) which inherits from the abstract `Command` and its `execute` method.
+3. Every command uses the `execute` method differently according to its needs. (For example, `AddMealCommand` would require saving of meals to a single database, while
+ `TrackCalorieCommand` would require reading from various databases for the desired result)
+4. The command can also communicate with the various storage components when it is executed, such as saving and loading of user, meals, foods, exercise data.
+5. In addition, the command also communicates with the UI Component to display the results of the execution of the command back to the user.
+6. In the case of command execution failures, an Exception Object (more precisely, an object of one of its subclasses, e.g. LifeTrackerException) is thrown.
+
+
+
+### Storage Component
+
+API: storage.java
+
+
+
+The `Storage` is the base class which all `Storage` components inherit from. There are currently four storages:
+
+1. `FoodStorage`: For parsing and storing all of the foods supported by _LifeTracker_
+2. `UserStorage`: For storing the user's profile
+3. `MealStorage`: For storing the meals that the user ate
+4. `ExerciseStorage`: For storing the exercises that the user did
+
+#### Interfaces
+
+To ensure that each `Storage` component only implements methods for writing and reading when needed, we created two interfaces
+
+1. `FileReadable`: Has `load()` method for `Storage` component to be able to read from a database
+2. `FileWritable`: Has `write()` method for `Storage` component to be able to write to a database
+
+For example, `FoodStorage` is not meant to be edited by user, hence it does not implement `FileWritable`
+
+# Implementation
+
+This section describes some noteworthy details on how certain features are implemented.
+
+## Add meal feature
+
+### Implementation
+
+The proposed mechanism for adding a meal is facilitated by `AddMealCommand`. It extends `Command` and overrides the
+`execute` method in the `Command` class.
+
+In this command, there are 2 ways for the user to add a meal to storage.
+
+1. Using a one-line command in their CLI in the format `add [DATE] /on [MEAL_TYPE] /type [FOOD_INDEX] /foods`
+2. Typing `add` into the CLI and following the printed prompts to enter the date in the specified format, type of meal and specific food.
+
+
+
+Step 1. As seen from the sequence diagram above, when the AddMealCommand is executed via the `execute` method in
+LifeTracker, the user's input is first parsed to determine how he/she wants to input it. Either method sets the food,
+date and meal type features necessary to create a new meal.
+
+Step 2. The constructor for the `Meal` class is called which instantiates a new instance of Meal using the
+parameters provided.
+
+Step 3. `mealStorage` saves the meal to the database and then `ui` prints out the confirmation of the meal added.
+
+### Design considerations
+
+#### Aspect: How to add meals
+
+- Alternative 1 (current choice): Use a one-line command for the CLI.
+ - Pros: Faster to input for experienced users.
+ - Cons: Format might be difficult for new users.
+- Alternative 2 (current choice): Follow printed prompts for data.
+ - Pros: Usage would be easier for new users.
+ - Cons: Slower to input for experienced users.
+
+Therefore, our group chose to implement both ways.
+
+## List feature
+
+### Implementation
+
+The proposed mechanism for listing stored foods, meals and exercises is facilitated by `ListCommand`. It extends `Command` and overrides the `execute` method in the `Command` class.
+
+Step 1: The user will input either `list foods`, `list meals`, `list exercises` based on which information the user wants to retrieve.
+
+Step 2: Based the input, `ListCommand` will call either `printAllFoods`, `printAllMeals`, or `printAllExercises` method of the `ui` object.
+
+Step 3: The `ui` will retrieve the relevant information from the storage and print out their details.
+
+
+
+### Design Considerations
+
+#### Aspect: How to list all the foods in the database, and the meals and the exercises of the user
+
+- Alternative 1 (current choice): List information based on input command.
+ - Pros: More concise, no unnecessary information.
+ - Cons: Slightly slower to input command.
+- Alternative 2: List all meals, exercises, and foods at once.
+ - Pros: Slightly faster to input command.
+ - Cons: Lots of unnecessary information would be displayed.
+
+## Delete feature
+
+### Implementation
+
+In order to delete a meal or exercise from their meal history, a user has to type either `delete /meal [MEAL_INDEX]` or `delete /exercise [EXERCISE_INDEX]`into the CLI. Users can see
+which meal or exercise they want to delete by viewing the respective csv files or using the list command.
+
+
+
+In the above implementation, DeleteMealCommand parses the user input to obtain the index to delete and proceeds to
+delete it via the method from mealStorage() and prints out the deleted meal to the user.
+
+### Design considerations
+
+#### Aspect: How to delete meals
+
+- Alternative 1 (current choice): Delete items from list based on index.
+ - Pros: Does not needlessly delete wanted items.
+ - Cons: Need to get the index from `list` command first.
+- Alternative 2: Clears all data.
+ - Pros: Faster input, no need for `list` command to retrieve index.
+ - Cons: Deletes data that user might want to keep.
+
+## View feature
+
+### Implementation
+
+The proposed view mechanism is facilitated by `ViewUserCommand`. It extends `Command` and overrides the
+`execute` method in the `Command` class.
+
+It stores the user's data internally as `user` and the meals consumed by the user as `meals`. It also
+initializes the UI for calories as `calorieUI`.
+
+Given below is an example usage scenario and how the view feature behaves at each step.
+
+Step 1. The user launches the application and calls the `view /[fieldname]` command. The `ViewUserCommand` will be
+initialized with the current user and meal storage state. `user` and `meals` will point to the user storage
+and meal state respectively.
+
+The method `parseCommand()` is then called to check and ensure that the `/[fieldname]`
+provided is valid information that can be viewed as well as the number of arguments provided is correct.
+
+
+
+Step 2. Based on the `/[fieldname]` that the user provided the different getter methods will be called in the entity
+`User` to return the appropriate information. In this case, the user has input the command `view /weight` which will
+call the getter method `getWeight()` in the entity `User` to return the current weight of the user and initializes the
+variable `weight` with that value.
+
+If the user's weight is equal to 0.0 then the method `printFieldNotStored()` in `GeneralUi` will be called to notify the
+user that that specific information has not been stored yet. Otherwise, the method `printWeight()` will be called to
+print out the weight of the user.
+
+
+
+For name, weight, height, age and gender there will a check done to see whether the field has information stored in it.
+If the fields are empty the user will be alerted and asked to update it.
+
+### Design considerations
+
+#### Aspect: How to view user data
+
+- Alternative 1 (current choice): Use a one-line for the CLI
+ - Pros: Faster to input for experienced users.
+ - Cons: Format might be difficult for new users.
+- Alternative 2 : Follow printed prompts for data.
+ - Pros: Usage would be easier for new users.
+ - Cons: Slower to input for experienced users.
+
+## Update feature
+
+### Implementation
+
+The proposed update mechanism is facilitated by `UpdateUserCommand`. It extends `Command` and overrides the `execute` method in the `Command` class.
+
+It stores the user's data internally as `user` and the meals consumed by the user as `meals`. It also
+initializes the UI for calories as `calorieUI`.
+
+Given below is an example usage scenario and how the view feature behaves at each step.
+
+It stores the user's data internally as `user`.
+
+Step 1. The user launches the application and calls the `update /[fieldname] [newInfo]` command. The `UpdateUserCommand` class will be
+initialized with the current user storage state. `user` will point to the user storage.
+
+The method `parseCommand()` is then called to check and ensure that the `/[fieldname]`
+provided is valid information that can be updated as well as the number of arguments provided is correct.
+
+
+
+Step 2. Based on the `/[fieldname]` that the user provided the different setter methods will be called in the entity
+`User` to update the appropriate information. In this case, the user has input the command `update /weight [newInfo]` which will
+call the setter method `setWeight()` in the entity `User` to return the set the current weight of the user to the newly
+updated one.
+
+The caloric limit is then recalculated with the calling of `calculateCaloricNeeds()` static method in User
+based on the new information provided and the caloric limit in `user` is then updated with `setCaloricLimit`.
+
+The new weight difference between the current weight and target weight is also shown with the calling of the static
+method `displayNewWeightDifference()`.
+
+The method `updateUser()` in userStorage is then called to update the user's detail in the storage.
+
+
+
+For updates made to weight, height, age and gender, there will be a call to the static method `calculateCaloricNeeds()`
+in the class User. This is done to ensure that with every new change, the caloric limit is recalculated. This recalculated
+caloric limit is will then be the new limit and the method `setCaloricLimit()` is called to update the user's daily caloric
+limit to the new one.
+
+For updates made to weight and targetWeight, there will be a call to the static method `displayNewWeightDifference()` and
+`displayNewTargetWeightDifference()` respectively to show the new difference between target weight and current weight of the user.
+
+At the end of every update, the userStorage will be updated accordingly.
+
+### Design considerations
+
+#### Aspect: How to update user data
+
+- Alternative 1 (current choice): Use a one-line for the CLI
+ - Pros: Faster to input for experienced users.
+ - Cons: Format might be difficult for new users.
+- Alternative 2 : Follow printed prompts for data.
+ - Pros: Usage would be easier for new users.
+ - Cons: Slower to input for experienced users.
+
+## Nutrition feature
+
+### Implementation
+
+The proposed update mechanism is facilitated by `NutritionCommand`. It extends `Command` and overrides the `execute` method in the `Command` class.
+
+Step 1: The user inputs `nutrition` into the command line.
+
+Step 2: The user will then be prompted to enter what food they would like to see the nutrition for.
+
+Step 3: A list of type `food` will then be created called `filteredFoods`, populated by foods from `foodStorage` that contains the user's input.
+
+Step 4: The list will then be displayed to the user, who can pick which food by its index.
+
+Step 5: The nutritional information for that food will then be displayed.
+
+
+
+### Design considerations
+
+#### Aspect: How to view nutritional information for foods
+
+- Alternative 1 (current choice): Follow prompts for information.
+ - Pros: User can get accurate information about the food.
+ - Cons: Slower input.
+- Alternative 2: Use a one line command for the CLI.
+ - Pros: Faster input.
+ - Cons: User might input food that's not in the database and therefore there is no nutritional information available.
+
+## Filter feature
+
+### Implementation
+
+This proposed mechanism for allowing the user to search for meals with a filter, facilitated by `FilterCaloriesCommand`. It extends `Command` and overrides the `execute` method in the `Command` class.
+
+Step 1. The user calls the `filter` command, specifying a particular calorie range through a upper and lower bound.
+
+Step 2. `FilterCaloriesCommand` will parse the lower and upper bound from the input.
+
+Step 3. `FilterCaloriesCommand` will then retrieve the meals that fit within that range from `FoodStorage`.
+
+Step 4. `FilterCaloiresCommand` will then print out the meals that has been filtered based on the lower and upper bound.
+
+
+
+### Design considerations
+
+#### Aspect: How to find foods from the database based on calories
+
+- Alternative 1 (current choice): Use a one-line for the CLI
+ - Pros: Faster to input for experienced users.
+ - Cons: Format might be difficult for new users.
+- Alternative 2 : Follow printed prompts for data.
+ - Pros: Usage would be easier for new users.
+ - Cons: Slower to input for experienced users.
+
+## Exercise feature
+
+### Implementation
+
+The proposed update mechanism is facilitated by `AddExerciseCommand`. It extends `Command` and overrides the `execute` method in the `Command` class.
+
+### Design considerations
+
+#### Aspect: How to add exercises
+
+- Alternative 1 (current choice): Use a one-line command for the CLI.
+ - Pros: Faster to input for experienced users.
+ - Cons: Format might be difficult for new users.
+- Alternative 2 (current choice): Follow printed prompts for data.
+ - Pros: Usage would be easier for new users.
+ - Cons: Slower to input for experienced users.
+
+## Track feature
+
+### Implementation
+
+The mechanism for tracking net calorie intake is facilitated by `TrackCalorieCommand`. It extends `Command` and overrides the `execute` method in the `Command` class.
+
+Step 1: The user will either input `track all` to view all history or `track /start [DATE] /end [DATE]` to filter the results based on dates
+Step 2a: Based the input, `TrackCalorieCommand` will either parse the start date from user input or set the start date to the earliest meal or exercise added by calling `getStartingDate`.
+Step 2b: Based the input, `TrackCalorieCommand` will either parse the end date from user input or set the end date to the latest meal or exercise added by calling `getEndingDate`.
+Step 3: `TrackCalorieCommand` will retrieve the meals and exercises filtered from the starting date by calling `getMealByDate` and `getExerciseByDate` respectively.
+Step 4: `TrackCalorieCommand` will iterate through the filtered meals and exercises day by day and print out the net calorie intake for each day.
+
+
+
+### Design considerations
+
+#### Aspect: How to track the calories of the user
+
+- Alternative 1 (current choice): Use a one-line command for the CLI.
+ - Pros: Faster to input for experienced users.
+ - Cons: Format might be difficult for new users.
+- Alternative 2 (current choice): Follow printed prompts for data.
+ - Pros: Usage would be easier for new users.
+ - Cons: Slower to input for experienced users.
+
+## Examples feature
+
+### Implementation
+
+The proposed mechanism for displaying examples of exercises and meals is facilitated by `ExamplesCommand`. It extends `Command` and overrides
+the `execute` method in the `Command` class.
+
+Step 1. The user calls the `examples` command, specifying whether they wish for `meal` or `exercise` to be displayed.
+
+Step 2. `ExamplesCommand` will parse the user input.
+
+Step 3. `ExamplesCommand` will retrieve either the examples of `meal` or examples of `exercise` based on the user input, from the `ExampleData` database.
+
+Step 4. The examples of `meal` or `exercise` will then be printed out and displayed for the user.
+
+
+
+### Design considerations
+
+#### Aspect: How to list examples of exercises and meals
+
+- Alternative 1 (current choice): List examples based on input command.
+ - Pros: More concise, no unnecessary information.
+ - Cons: Slightly slower to input command.
+- Alternative 2: List all examples.
+ - Pros: Slightly faster to input command.
+ - Cons: Lots of unnecessary information would be displayed.
+
+# Appendix: Requirements
## Product scope
+
### Target user profile
-{Describe the target user profile}
+- Is an NUS student
+- Looking to lose/maintain their weight
+- Looking to make healthier choices in terms of food
+- Can type fast
+- Prefers typing to mouse interactions
+- Is reasonably comfortable using CLI apps
### Value proposition
-{Describe the value proposition: what problem does it solve?}
+For individuals trying to lose weight, managing their daily caloric intake is crucial. However, many may find it
+hard to track and manage their calories. _LifeTracker_ allows users to easily automate the tracking of their calories
+and keep a record of their daily caloric intake.
+
+_LifeTracker_ can also keep track of the exercises that users have done and factor it in to their daily calories lost. This allows
+the user to keep track of their net calorie gain on a daily basis.
+
+### User Stories
+
+Version
+As a ...
+I want to ...
+So that I can ...
+ +v1.0
+new user
+see usage instructions
+refer to them when I forget how to use the application
+ +v1.0
+user
+calculate my caloric needs based on my height and weight
+lead a healthy lifestyle within my caloric needs
+ +v1.0
+user
+add a meal
+keep track of the food I have eaten on a particular day
+ +v1.0
+user
+delete a meal
+remove a meal if I entered it in wrongly
-## User Stories +v1.0
+user
+view my previous meals
+track the calories of each meal
-|Version| As a ... | I want to ... | So that I can ...| -|--------|----------|---------------|------------------| -|v1.0|new user|see usage instructions|refer to them when I forget how to use the application| -|v2.0|user|find a to-do item by name|locate a to-do without having to go through the entire list| +v1.0
+user
+key in my weight on a daily basis
+keep track of my weight loss/gain
+ +v1.0
+user
+see the amount of calories left I have in the day
+not exceed my daily caloric limit
+ +v2.0
+user
+search for a type of food and view its nutritional contents
+make a more informed choice about what to eat
+ +v2.0
+user
+search for meals within a specific calorie range
+decide which meal to consume
+ +v2.0
+user
+enter the type and duration of exercise I have completed
+keep better track of my physical activies
+ +v2.1
+user
+be inspired to work out
+stay in shape
+ +v2.1
+user
+search based on a filter
+have results that better suit my needs
+Information
+/[fieldName]
+ +Name
+/name
+ +Weight
+/weight
+ +Height
+/height
+ +Age
+/age
+ +Gender
+/gender
+ +Daily caloric limit
+/caloricLimit
+ +Calories remaining for today
+/caloriesLeft
+ +Target weight
+/targetWeight
+Information
+/[fieldName]
+Comments
+ +Name
+/name
+For more than one name, separate with an underscore. E.g Firstname_LastName
+ +Weight
+/weight
+Weight can only take in numbers between 0 and 700 kg.
+ +Height
+/height
+Height can only take in numbers between 0 and 300 cm.
+ +Age
+/age
+Age can only take in numbers between 0 and 120 years old.
+ +Gender
+/gender
+Gender can only take in male or female as arguments.
+ +Target weight
+/targetWeight
+TargetWeight can only take in numbers between 0 and 700 kg.
+Action
+Format, Examples
+ +View
+view /[fieldName]Update
+update /[fieldName]Add
+add /on [date] /type [MealType] /foods [foods] OR addList
+list [foods, meals, exercises]Delete
+delete /[meal, exercise] [index]Filter
+filter [lower_bound] [upper_bound]Nutrition
+nutritionExercise
+exercise /type [exercise_name] /description [exercise_description] /calories [calories_burnt] /on [date]Track
+track all OR track /start [start_date] /end [end_date]Examples
+examples [meal, exercise]Help
+helpExit
+bye