Program.cs

using ImageMagick;

namespace BulkImageConverter
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            DisplayWelcomeMessage();

            while (true)
            {
                DisplayMainMenu();

                string choice = Console.ReadLine().Trim().ToLower();
                switch (choice)
                {
                    case "1":
                        Console.Write("Enter the path of the file or drag and drop the file: ");
                        string singleFilePath = Console.ReadLine().Trim('"');
                        ConvertSingleFile(singleFilePath);
                        break;

                    case "2":
                        ConvertMultipleFiles();
                        break;

                    case "/help":
                        DisplayInstructions();
                        break;

                    case "/exit":
                        Console.WriteLine("Exiting program. Goodbye!");
                        return;

                    default:
                        WriteLineWithColor("Invalid option selected. Please try again.", ConsoleColor.Red);
                        break;
                }
            }
        }

        private static void DisplayWelcomeMessage()
        {
            Console.Clear();
            WriteLineWithColor("============================================", ConsoleColor.Magenta);
            WriteLineWithColor("         Welcome to Image Converter         ", ConsoleColor.Magenta);
            WriteLineWithColor("============================================", ConsoleColor.Magenta);
        }

        private static void DisplayMainMenu()
        {
            Console.WriteLine("\nMain Menu:");
            Console.WriteLine("1. Convert a single image.");
            Console.WriteLine("2. Convert multiple images from a directory.");
            Console.WriteLine("Type '/help' for instructions or '/exit' to quit.");
            Console.Write("Enter your choice: ");
        }

        private static void ConvertSingleFile(string filePath)
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Available image types: webp, png, bmp, tif, gif, jpg, jpeg");
            Console.Write("Enter the target image type: ");
            string targetType = Console.ReadLine();

            Console.Write("Add watermark? (yes/no): ");
            string addWatermark = Console.ReadLine().ToLower();

            string watermarkPathOrText = null;
            Gravity watermarkPosition = Gravity.Center;

            if (addWatermark == "yes")
            {
                int watermarkTypeChoice;
                bool isValidChoice = false;

                do
                {
                    // Prompt user for watermark type: text or image.
                    Console.Write("Choose watermark type (1: text, 2: image): ");

                    if (int.TryParse(Console.ReadLine(), out watermarkTypeChoice))
                    {
                        if (watermarkTypeChoice == 1 || watermarkTypeChoice == 2)
                        {
                            isValidChoice = true;
                        }
                        else
                        {
                            Console.WriteLine("Invalid choice. Please enter 1 for text or 2 for an image.");
                        }
                    }
                    else
                    {
                        Console.WriteLine("Invalid input. Please enter a valid number (1 or 2).");
                    }
                } while (!isValidChoice);

                // Depending on the choice, either get the text or path.
                watermarkPathOrText = GetWatermarkPathOrText(watermarkTypeChoice.ToString());

                if (watermarkTypeChoice == 2) // Only ask for watermark position if it's an image watermark.
                {
                    // Now, get the watermark position.
                    watermarkPosition = GetWatermarkPosition();
                }
            }

            Console.Write("Delete original file after conversion? (yes/no): ");
            string deleteOriginal = Console.ReadLine().ToLower();
            if (deleteOriginal == "yes")
            {
                Console.Write("Are you sure you want to delete the original file? (yes/no): ");
                string confirmDelete = Console.ReadLine().ToLower();
                deleteOriginal = confirmDelete;
            }

            Console.ResetColor();
            ConvertImage(filePath, targetType, watermarkPathOrText, deleteOriginal == "yes", watermarkPosition);
        }

        private static void ConvertImage(string sourceFilePath, string targetFileName, string watermarkPathOrText, bool deleteOriginal, Gravity watermarkPosition = Gravity.Center)
        {
            try
            {
                string targetFilePath = Path.Combine(Path.GetDirectoryName(sourceFilePath), targetFileName);
                using (MagickImage image = new MagickImage(sourceFilePath))
                {
                    if (!string.IsNullOrEmpty(watermarkPathOrText))
                    {
                        // Check if the provided watermark is a text or an image path
                        if (File.Exists(watermarkPathOrText))
                        {
                            using (MagickImage watermark = new MagickImage(watermarkPathOrText))
                            {
                                watermark.Evaluate(Channels.Alpha, EvaluateOperator.Divide, 2.0);  // Adjusting opacity (optional)
                                image.Composite(watermark, watermarkPosition, CompositeOperator.Over);
                            }
                        }
                        else  // Treat as text watermark
                        {
                            MagickReadSettings readSettings = new MagickReadSettings()
                            {
                                BackgroundColor = MagickColors.Transparent, // Text background will be transparent
                                FillColor = MagickColors.White,             // Text will be white
                                FontPointsize = 30,                         // Font size
                                Width = image.Width                         // Width of the text canvas
                            };

                            using (MagickImage textWatermark = new MagickImage($"label:{watermarkPathOrText}", readSettings))
                            {
                                image.Composite(textWatermark, watermarkPosition, CompositeOperator.Over);
                            }
                        }
                    }
                    image.Write(targetFilePath);
                }

                if (deleteOriginal)
                {
                    File.Delete(sourceFilePath);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error converting {sourceFilePath} to {targetFileName}: {ex.Message}");
            }
        }

        static void ConvertMultipleFiles(string rootDirectory = null, string watermarkPath = null)
        {
            Console.ForegroundColor = ConsoleColor.Blue;
            if (string.IsNullOrEmpty(rootDirectory))
            {
                Console.Write("Enter the directory path or drag and drop the folder: ");
                rootDirectory = Console.ReadLine().Trim('"');
            }

            bool includeSubdirs = false; // Initialize as false
            bool renameBasedOnFolder = false; // Initialize as false
            Gravity watermarkPosition = Gravity.Center; // Initialize watermark position

            int watermarkTypeChoice = 0; // Initialize outside of the if block
            bool isValidChoice = false;

            do
            {
                // Prompt user for watermark type: text or image.
                Console.Write("Choose watermark type (1: text, 2: image): ");

                if (int.TryParse(Console.ReadLine(), out watermarkTypeChoice))
                {
                    if (watermarkTypeChoice == 1 || watermarkTypeChoice == 2)
                    {
                        isValidChoice = true;

                        if (string.IsNullOrEmpty(watermarkPath))
                        {
                            Console.Write("Add watermark? (yes/no): ");
                            string addWatermark = Console.ReadLine().ToLower();
                            if (addWatermark == "yes")
                            {
                                // Depending on the choice, either get the text or path.
                                watermarkPath = GetWatermarkPathOrText(watermarkTypeChoice.ToString());

                                if (watermarkTypeChoice == 2) // Only ask for watermark position if it's an image watermark.
                                {
                                    // Now, get the watermark position.
                                    watermarkPosition = GetWatermarkPosition();
                                }
                            }
                        }
                    }
                    else
                    {
                        Console.WriteLine("Invalid choice. Please enter 1 for text or 2 for an image.");
                    }
                }
                else
                {
                    Console.WriteLine("Invalid input. Please enter a valid number (1 or 2).");
                }
            } while (!isValidChoice);

            Console.Write("Include subdirectories? (yes/no): ");
            string includeSubdirsChoice = Console.ReadLine().ToLower();
            if (includeSubdirsChoice == "yes")
            {
                includeSubdirs = true;
            }

            Console.Write("Rename files based on folder name? (yes/no): ");
            string renameBasedOnFolderChoice = Console.ReadLine().ToLower();
            if (renameBasedOnFolderChoice == "yes")
            {
                renameBasedOnFolder = true;
            }

            List<string> imageExtensions = new List<string> { "webp", "png", "bmp", "tif", "gif", "jpg", "jpeg" };
            Console.WriteLine("Available image types: webp, png, bmp, tif, gif, jpg, jpeg");
            Console.Write("Enter the source image type: ");
            string sourceType = Console.ReadLine();
            Console.Write("Enter the target image type: ");
            string targetType = Console.ReadLine();

            Console.Write("Delete original files after conversion? (yes/no): ");
            string deleteOriginal = Console.ReadLine().ToLower();
            if (deleteOriginal == "yes")
            {
                Console.Write("Are you sure you want to delete the original files? (yes/no): ");
                string confirmDelete = Console.ReadLine().ToLower();
                deleteOriginal = confirmDelete;
            }

            Console.ResetColor();

            if (sourceType == "all")
            {
                foreach (var extension in imageExtensions)
                {
                    ConvertImagesInDirectory(rootDirectory, extension, targetType, watermarkPath, deleteOriginal == "yes", includeSubdirs, renameBasedOnFolder, watermarkPosition);
                }
            }
            else
            {
                ConvertImagesInDirectory(rootDirectory, sourceType, targetType, watermarkPath, deleteOriginal == "yes", includeSubdirs, renameBasedOnFolder, watermarkPosition);
            }
        }

        // Now, we also need to adjust the ConvertImagesInDirectory method to accept and process the renaming flag:

        private static void ConvertImagesInDirectory(string directoryPath, string sourceType, string targetType, string watermarkPath, bool deleteOriginal, bool includeSubdirs, bool renameBasedOnFolder, Gravity watermarkPosition = Gravity.Center)
        {
            string[] sourceFiles = Directory.GetFiles(directoryPath, $"*.{sourceType}");
            int imageIndex = 1;
            foreach (var sourceFile in sourceFiles)
            {
                string targetFileName;
                if (renameBasedOnFolder)
                {
                    string folderName = new DirectoryInfo(directoryPath).Name;
                    targetFileName = $"{folderName}_{imageIndex}.{targetType}";
                }
                else
                {
                    targetFileName = $"{Path.GetFileNameWithoutExtension(sourceFile)}.{targetType}";
                }
                ConvertImage(sourceFile, targetFileName, watermarkPath, deleteOriginal, watermarkPosition);
                imageIndex++;
            }

            if (includeSubdirs)
            {
                string[] subDirectories = Directory.GetDirectories(directoryPath);
                foreach (var subDir in subDirectories)
                {
                    ConvertImagesInDirectory(subDir, sourceType, targetType, watermarkPath, deleteOriginal, includeSubdirs, renameBasedOnFolder, watermarkPosition);
                }
            }
        }

        private static string GetWatermarkPathOrText(string watermarkTypeChoice)
        {
            Console.Write("Enter the watermark path or text: ");
            string watermarkPathOrText = Console.ReadLine().Trim('"');

            if (watermarkTypeChoice == "1")
            {
                // This is a text watermark, so return it as is.
                return watermarkPathOrText;
            }
            else if (watermarkTypeChoice == "2")
            {
                // This is an image watermark, so check if it's a valid file path.
                if (File.Exists(watermarkPathOrText))
                {
                    return watermarkPathOrText;
                }
                else
                {
                    Console.WriteLine("Invalid image watermark path.");
                    return null;
                }
            }
            else
            {
                Console.WriteLine("Invalid watermark type choice.");
                return null;
            }
        }

        private static Gravity GetWatermarkPosition()
        {
            Console.WriteLine("Choose watermark position:");
            Console.WriteLine("1. Top");
            Console.WriteLine("2. Middle");
            Console.WriteLine("3. Bottom");

            while (true)
            {
                Console.Write("Enter the position (1/2/3): ");
                string positionChoice = Console.ReadLine();
                if (positionChoice == "1")
                {
                    return Gravity.North;
                }
                else if (positionChoice == "2")
                {
                    return Gravity.Center;
                }
                else if (positionChoice == "3")
                {
                    return Gravity.South;
                }
                else
                {
                    Console.WriteLine("Invalid choice. Please enter 1, 2, or 3.");
                }
            }
        }

        // ... rest of the methods ...

        private static string GetInput(string prompt)
        {
            Console.Write(prompt);
            return Console.ReadLine().Trim('"');
        }

        private static bool GetYesOrNo(string prompt)
        {
            while (true)
            {
                string response = GetInput(prompt).Trim().ToLower();
                if (response == "yes") return true;
                if (response == "no") return false;
                WriteLineWithColor("Please answer with 'yes' or 'no'.", ConsoleColor.Red);
            }
        }

        private static string GetInputFromOptions(string prompt, List<string> options)
        {
            while (true)
            {
                string response = GetInput(prompt).Trim().ToLower();
                if (options.Contains(response))
                    return response;

                WriteLineWithColor($"Please select a valid option from: {string.Join(", ", options)}", ConsoleColor.Red);
            }
        }

        private static void WriteLineWithColor(string message, ConsoleColor color)
        {
            Console.ForegroundColor = color;
            Console.WriteLine(message);
            Console.ResetColor();
        }

        private static void DisplayInstructions()
        {
            Console.Clear();
            WriteLineWithColor("============================================", ConsoleColor.Magenta);
            WriteLineWithColor("                Instructions                ", ConsoleColor.Magenta);
            WriteLineWithColor("============================================", ConsoleColor.Magenta);

            Console.WriteLine("\n1. When prompted, you can choose to convert either a single image or multiple images from a directory.");
            Console.WriteLine("2. For a single image conversion, provide the path for the image you want to convert.");
            Console.WriteLine("3. For converting multiple images, you can enter the directory path of the images. You also have an option to include subdirectories.");
            Console.WriteLine("4. Specify the target image type (e.g., jpg, png).");
            Console.WriteLine("5. Optionally, you can add a watermark to the image(s). If you choose to, you will be prompted for the watermark image path.");
            Console.WriteLine("6. Optionally, you can decide to delete the original file(s) after conversion.");
            Console.WriteLine("7. The converted image(s) will be saved in the same directory as the original file(s).");
            Console.WriteLine("8. At any point, you can type '/exit' to leave the program.");

            Console.Write("\nPress ENTER to return to the main menu.");
            Console.ReadLine();
        }
    }
}