# Import the MongoClient class from the pymongo library.
# This will allow us to connect to a MongoDB database.
from pymongo import MongoClient

# Define the username for the MongoDB database. This should be a valid user with appropriate permissions.
username = 'infinitepy'

# Define the password for the MongoDB database. Make sure that this password is correct.
# Never expose or hard-code passwords in your code for security reasons. Use environment variables or secret managers in real applications.
password = 'ilovepyth0n'

# Create a MongoClient object. This object represents a client connection to the MongoDB database.
# We use an f-string to format the connection string with the username and password.
# The connection URI includes the username, password, and cluster information.
client = MongoClient(f'mongodb+srv://{username}:{password}@infinitepy-cluster.s05fljv.mongodb.net/?retryWrites=true&w=majority&appName=infinitepy-cluster')

# Using the client instance, fetch the list of all database names
# list_database_names() returns a list of strings, where each string is the name of a database.
for db_name in client.list_database_names():
    # Print each database name to the console
    print(db_name)

# Access the sample_db database; if it doesn't exist, MongoDB creates it when you first store some data in it.
# The 'client.sample_db' syntax is used to access the database.
db = client.sample_db

# Access the collection named 'my_collection' in the sample_db database
collection = db.my_collection

# Create a dictionary representing the document to be inserted into the collection
# The document contains information about a person: name, age, and city
document = {"name": "John Doe", "age": 29, "city": "New York"}

# Insert the document into the 'my_collection' collection
# The insert_one method returns a result object that contains information about the insertion
result = collection.insert_one(document)

# Print the unique ID of the inserted document
# The inserted_id attribute of the result object contains this ID
print("Document id inserted: {document_id}".format(document_id=result.inserted_id))

# Access the sample_db database; if it doesn't exist, MongoDB creates it when you first store some data in it.
# The 'client.sample_db' syntax is used to access the database.
db = client.sample_db

# Access the collection named 'my_collection' in the sample_db database.
# A collection in MongoDB is similar to a table in a relational database.
collection = db.my_collection

# Find a single document in the 'my_collection' collection where the 'name' field equals "John Doe".
# The method 'find_one' returns the first match found.
result = collection.find_one({"name": "John Doe"})

# Print the result to the console.
# If a document with the 'name' "John Doe" is found, it will print that document.
# If no such document exists, it will print 'None'.
print(result)

# Access the sample_db database; MongoDB creates it if it doesn’t exist.
# The 'client.sample_db' syntax is used to access the database.
db = client.sample_db

# Access the collection named 'my_collection' within the sample_db database.
# A collection in MongoDB is similar to a table in a relational database.
collection = db.my_collection

# Define a list of documents to be inserted into 'my_collection'.
# Each document is represented as a Python dictionary with key-value pairs.
documents = [
    {"name": "Alice", "age": 25, "city": "London"},
    {"name": "Bob", "age": 30, "city": "San Francisco"},
]

# Insert the list of documents into the collection.
# The insert_many method inserts multiple documents at once and returns an object containing the inserted_ids.
result = collection.insert_many(documents)

# Print the unique IDs of the inserted documents.
# The inserted_ids attribute of the result object contains these IDs.
print("Documents inserted with IDs:", result.inserted_ids)

# Access the sample_db database; if it doesn't exist, MongoDB creates it when you first store some data in it.
# The 'client.sample_db' syntax is used to access the database.
db = client.sample_db

# Access the collection named 'my_collection' in the sample_db database
collection = db.my_collection

# Insert the document into the 'my_collection' collection
# The insert_one method returns a result object that contains information about the insertion
result = collection.update_one(
    {"name": "John Doe"},
    {"$set": {"age": 30}}
)

# Check if the update was successful
if result.modified_count > 0:
    print("Document updated successfully.")
else:
    print("No document was updated.")

# Access the sample_db database; MongoDB creates it if it doesn’t exist.
# The 'client.sample_db' syntax is used to access the database.
db = client.sample_db

# Access the collection named 'my_collection' within the sample_db database.
# A collection in MongoDB is similar to a table in a relational database.
collection = db.my_collection

# Attempt to delete a single document from the 'my_collection' collection
# where the 'name' field is "John Doe".
# `delete_one` method deletes the first document that matches the filter criteria.
result = collection.delete_one({"name": "John Doe"})

# Check if a document was actually deleted by examining the 'deleted_count' attribute.
# This attribute returns the number of documents that were deleted.
if result.deleted_count > 0:
    # If deleted_count is greater than 0, it means at least one document was deleted.
    print("Document deleted successfully.")
else:
    # If deleted_count is 0, it means no document matched the filter criteria.
    print("No document was deleted.")

# Access the sample_db database; MongoDB creates it if it doesn’t exist.
# The 'client.sample_db' syntax is used to access the database.
db = client.sample_db

# Access the collection named 'my_collection' within the sample_db database.
# A collection in MongoDB is similar to a table in a relational database.
collection = db.my_collection

# Define an aggregation pipeline to process documents in the collection.
# The pipeline is a list of stages, where each stage transforms the documents as they pass through.
# The stages are processed in order from the first to the last.
pipeline = [
    # The $match stage filters the documents by the specified condition.
    # Here, we are only interested in documents where the age field is greater than or equal to 25.
    {"$match": {"age": {"$gte": 25}}},

    # The $group stage groups the documents by a specified identifier.
    # Here, we are grouping documents by the 'city' field.
    # The '_id' field is used as the group identifier.
    # The 'average_age' field is calculated as the average value of the 'age' field for each group.
    {"$group": {"_id": "$city", "average_age": {"$avg": "$age"}}},
]

# Execute the aggregation pipeline on the collection.
# The aggregate() method returns an iterable with the results of the pipeline.
result = collection.aggregate(pipeline)

# Iterate over the result and print each document.
# Each document in the result represents a city and its corresponding average age.
for doc in result:
    print(doc)

# Access the sample_db database; MongoDB creates it if it doesn’t exist.
# The 'client.sample_db' syntax is used to access the database.
db = client.sample_db

# Access the collection named 'my_collection' within the sample_db database.
# A collection in MongoDB is similar to a table in a relational database.
collection = db.my_collection

# Define an aggregation pipeline to process the data in the collection.
# The pipeline contains a sequence of stages, each represented by a document.
pipeline = [
    # The $group stage groups documents by the 'city' field.
    # It creates a new document for each group where '_id' is the city name.
    # It also calculates the maximum age for each group and stores it in 'max_age'.
    {"$group": {"_id": "$city", "max_age": {"$max": "$age"}}},

    # The $sort stage sorts the grouped documents by the 'max_age' field in descending order (-1).
    {"$sort": {"max_age": -1}}
]

# Execute the aggregation pipeline on the collection.
# 'collection.aggregate(pipeline)' returns a cursor to the result of the aggregation.
result = collection.aggregate(pipeline)

# Iterate over the documents in the result cursor.
# Each document in 'result' is a dictionary containing '_id' (the city name) and 'max_age'.
for doc in result:
    # Print the city name and maximum age for each group.
    print(f"City: {doc['_id']}, Max Age: {doc['max_age']}")

import logging

# Create a logger object with the name 'mongo_logger'
mongo_logger = logging.getLogger('mongo_logger')

# Set the logging level to DEBUG. This means that all messages with the level DEBUG and above will be logged
mongo_logger.setLevel(logging.DEBUG)

# Create handlers that will print log messages to the console (standard output) write log messages to a file named 'mongo_logger.log'
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('mongo_logger.log')

# Define a formatter that specifies the format of the log messages
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# Set the formatter for the console handler and for the file handler
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# Add the console handler to the logger. This means that log messages will be output to the console
mongo_logger.addHandler(console_handler)
# Add the file handler to the logger. This means that log messages will be written to the 'mongo_logger.log' file
mongo_logger.addHandler(file_handler)

# Function to get a specific database
def get_database(db_name):
    # Log that we are accessing the specified database
    mongo_logger.info(f"Accessing the '{db_name}' database.")
    # Return the database object from the client
    return client[db_name]

# Function to get a specific collection from a database
def get_collection(db, collection_name):
    # Log that we are accessing the specified collection within the given database
    mongo_logger.info(f"Accessing the '{collection_name}' collection within the '{db.name}' database.")
    # Return the collection object from the database
    return db[collection_name]

# Function to insert multiple book documents into a collection
def insert_books(collection, books):
    # Log that we are inserting new book documents
    mongo_logger.info("Inserting new book documents into the collection.")
    # Insert the list of books into the collection using insert_many
    result = collection.insert_many(books)
    # Log the IDs of the inserted documents
    mongo_logger.info(f'Inserted book IDs: {result.inserted_ids}')
    # Return the result of the insert operation
    return result

# Function to find books by a specific author in a collection
def find_books_by_author(collection, author_name):
    # Log that we are querying for books by the specified author
    mongo_logger.info(f"Querying the collection for all books authored by {author_name}.")
    # Query the collection for books with the given author name
    books = collection.find({"author": author_name})
    # Log the number of books found (convert cursor to list to count)
    mongo_logger.info(f"Found {len(list(books))} books by {author_name}.")
    # Return the cursor to the list of books found
    return books

# Function to update the genre of a book by its title
def update_book_genre(collection, title, new_genre):
    # Log that we are updating the genre of the specified book
    mongo_logger.info(f"Updating the genre of '{title}' to '{new_genre}'.")
    # Update the genre of the book with the given title
    update_result = collection.update_one(
        {"title": title},
        {"$set": {"genre": new_genre}}
    )
    # Log the number of matched and modified documents
    mongo_logger.info(f'Matched {update_result.matched_count} document(s) and modified {update_result.modified_count} document(s).')
    # Return the result of the update operation
    return update_result

# Function to delete a book by its title
def delete_book(collection, title):
    # Log that we are deleting the book with the specified title
    mongo_logger.info(f"Deleting the book with the title '{title}'.")
    # Delete the book document with the given title
    delete_result = collection.delete_one({"title": title})
    # Log the number of documents deleted
    mongo_logger.info(f'Deleted {delete_result.deleted_count} document(s).')
    # Return the result of the delete operation
    return delete_result

# The following script performs basic operations on a library database.
# It assumes the existence of certain helper functions: get_database, get_collection,
# insert_books, find_books_by_author, update_book_genre, and delete_book.

if __name__ == "__main__":
    # This line checks if the script is run as the main module and not imported as a part of another module.

    # Initialize the database connection with the database named 'library'
    db = get_database('library')

    # Access the 'books' collection from the 'library' database
    books_collection = get_collection(db, 'books')

    # Define a list of new books to be added to the collection
    new_books = [
        {
            "title": "The Catcher in the Rye",
            "author": "J.D. Salinger",
            "year": 1951,
            "genre": "Fiction"
        },
        {
            "title": "To Kill a Mockingbird",
            "author": "Harper Lee",
            "year": 1960,
            "genre": "Fiction"
        },
        {
            "title": "Python Crash Course",
            "author": "Eric Matthes",
            "year": 2015,
            "genre": "Programming"
        }
    ]

    # Insert the list of new books into the 'books' collection
    insert_books(books_collection, new_books)

    # Find all books by the author J.D. Salinger in the 'books' collection
    salinger_books = find_books_by_author(books_collection, "J.D. Salinger")

    # Log the books found by the author J.D. Sali