Simple Version Control System

Your task is to implement a simplified version control system in the form of a single class. The system should simulate basic version control operations while maintaining an underlying data structure to track commits and branches.

Requirements

1. Initialization: When the system starts, it should have one branch named main containing an initial commit with an id of 0 and the message "root".

2. Commit Operation: Implement a method commit(message) that creates a new commit on the current branch. Each commit should have:

   • A unique, incrementing id (starting from 1).
   • A commit message provided as input.
   • A reference to its parent commit (i.e., the previous commit on that branch).

3. Branching: Implement a method branch(branch_name) that creates a new branch starting at the current commit of the active branch. The new branch should be independent and allow further commits from that point onward.

4. Checkout: Implement a method checkout(branch_name) that switches the current branch to the specified branch. If the branch does not exist, decide how to handle it (e.g., throw an error or create the branch, but be consistent in your approach).

5. Log Retrieval: Implement a method log() that returns a list (or equivalent collection) of commit messages from the current branch. The log should start from the current commit and walk back through the parent chain until it reaches the initial commit.

6. Merge: Implement a method merge(branch_name) that merges the commits of the specified branch into the current branch. For this simplified model, assume the following:

   • The branch to be merged is assumed to be linear (i.e., a sequence of commits without further branches).
   • Any commits in the specified branch that aren’t already in the current branch should be appended to the current branch in order.
   • You should create a merge commit on the current branch that represents this merge (with its own unique id and a message indicating that a merge occurred). You may design the merge commit message as you see fit.

Additional Guidelines

• Error Handling: Decide and document how your implementation handles edge cases (e.g., checking out or merging a non-existent branch).
• Data Structure Design: Consider efficient ways to store and retrieve the commit history and branch pointers. The simplicity or complexity of your design is up to you—explain your choices if necessary.
• Interface: The class’s public methods should at least include commit, branch, checkout, log, and merge.

Example Scenario

1. Start with the main branch containing commit 0 ("root").
2. Commit a few changes on main using commit(message).
3. Create a new branch feature using branch("feature").
4. On the feature branch, commit additional changes.
5. Switch back to main using checkout("main").
6. Merge the feature branch into main using merge("feature").
7. Retrieve the log for the current branch with log() to see the updated commit history.

Implement this functionality in the programming language of your choice. Ensure your solution is well-organized and correctly handles the requirements specified above.