# This script creates a new directory called "my_extension" and navigates into it using the "cd" command.

# First, create a new directory called "my_extension"
mkdir my_extension

# Then, navigate into the newly created directory using the "cd" command
cd my_extension/

# This script initializes a virtual environment to avoid conflicts with the Python environment.

# First, it creates a virtual environment named ".venv" using the "venv" module of Python 3.
python3 -m venv .venv

# Then, it activates the virtual environment by sourcing the "activate" script located in the ".venv/bin" directory.
source .venv/bin/activate

# Importing the necessary module for creating a setup file
from setuptools import setup
# Importing the os module for accessing operating system functionalities
import os

# Defining the details of our extension module
setup(
    # Name of the extension module
    name='my_extension',
    # Version of the extension module
    version='0.1',
    # Description of the extension module
    description='A simple Python C extension type.',
    # List of extension modules to be included
    ext_modules=[
        # Dictionary containing the name and source code files of the extension module
        {
            # Name of the extension module
            'name': 'fputs_ext',
            # List of source code files for the extension module
            'sources': ['fputs.c']
        }
    ]
)

// This script creates an extension module called fputs_ext that uses the source code file fputs.c

// Include necessary libraries
#include <stdio.h>
#include <string.h>

// Define the method for fputs
static PyObject* method_fputs(PyObject *self, PyObject *args) {
    const char *str; // Declare a variable to store the string
    FILE *file; // Declare a variable to store the file
    int len; // Declare a variable to store the length of the string
    
    // Parse the arguments passed to the method
    if (!PyArg_ParseTuple(args, "sO", &str, &file)) {
        return NULL;
    }
    
    // Use the fputs function to write the string to the file
    len = fputs(str, file);
    
    // Return the length of the string
    Py_RETURN_LONG(len);
}

# This script compiles an extension module using setuptools.
# The module is built in-place, meaning it is built in the current directory.

# The first line specifies the interpreter to use, in this case python3.
# This ensures that the script is executed using the correct version of Python.

#!/bin/bash

# The next line calls the setup.py file, which contains the necessary instructions for building the extension module.
# The build_ext command is used to build the module, and the --inplace option specifies that it should be built in the current directory.

python3 setup.py build_ext --inplace

# Import the compiled extension module "my_extension"
import my_extension

# Open a file named "test.txt" in write mode and assign it to the variable "file"
file = open('test.txt', 'w')

# Call the "fputs" function from the "my_extension" module, passing in the string "Hello, world!\n" and the file object "file" as arguments
my_extension.fputs("Hello, world!\n", file)

# Call the "fputs" function again, passing in the string "This is a test." and the file object "file" as arguments, and print the return value
print(my_extension.fputs("This is a test.", file))

# Close the file
file.close()

// This script prints "Hello, world!" and "This is a test." to the console and writes them to a file called "test.txt".

// Declares a function named "print" that takes in a parameter "message".
function print(message) {
  // Prints the value of "message" to the console.
  console.log(message);
  // Returns the number of bytes written to the file.
  return message.length;
}

// Calls the "print" function with the string "Hello, world!" as the argument.
print("Hello, world!");
// Calls the "print" function with the string "This is a test." as the argument.
print("This is a test.");

// Stores the returned value from the first "print" function call in a variable named "bytesWritten".
var bytesWritten = print("Hello, world!");
// Prints the value of "bytesWritten" to the console.
console.log(bytesWritten);

// Opens the file "test.txt" and writes the string "Hello, world!" to it.
// Note: This code assumes that the file already exists.
fs.writeFile("test.txt", "Hello, world!", function(err) {
  // Checks for any errors while writing to the file.
  if (err) {
    // Prints the error message to the console.
    console.log(err);
  } else {
    // If no errors, prints a success message to the console.
    console.log("Successfully wrote to file!");
  }
});

// This function takes in a string and a file object as arguments and writes the string to the file.
static PyObject* method_fputs(PyObject *self, PyObject *args) {
    const char *str; // Declaring a variable to store the string
    FILE *file; // Declaring a variable to store the file object
    int len; // Declaring a variable to store the length of the string
    
    // Using PyArg_ParseTuple() to parse the arguments passed to the function
    // "sO" specifies that the first argument is a string and the second argument is a Python object
    // &str and &file are pointers to the variables where the parsed values will be stored
    if (!PyArg_ParseTuple(args, "sO", &str, &file)) {
        return NULL; // If the parsing fails, return NULL
    }
    
    // Using fputs() to write the string to the file
    len = fputs(str, file);
 
    // Using PyErr_SetString() to raise an exception if the string is too short
    PyErr_SetString(PyExc_ValueError, "The string is too short.");
}

# Import the module "my_extension" to use its functions
import my_extension

# Open a file named "test.txt" in write mode and assign it to the variable "file"
file = open('test.txt', 'w')

# Use the "fputs" function from the "my_extension" module to write the string "H" to the file
my_extension.fputs("H", file)

# The above code will raise an error because the "fputs" function expects a string of more than one character to be written to the file. 
# To avoid this error, we can pass in a longer string or use the "PyErr_SetString()" function to raise a ValueError with a custom message.

// This function is used to get a constant value from our module.
static PyObject* method_get_constant(PyObject *self) {
    // We define a static constant variable named MY_CONSTANT and assign it a value of 42.
    static const int MY_CONSTANT = 42;
    // We use the PyLong_FromLong() function from the Python API to convert the constant value to a Python long integer object.
    return PyLong_FromLong(MY_CONSTANT);
}

# Defining a new constant called MY_CONSTANT with the value of 42
MY_CONSTANT = 42

# Importing the module "my_extension" to access its functions
import my_extension

# Printing the value of the constant "MY_CONSTANT" by calling the function "get_constant" from the "my_extension" module
print(my_extension.get_constant())