// static methods in Program class

static void TestFilter(
    Image image,
    IImageFilter filter,
string suffix)
{
    Image result = filter.Apply(image);
    string path = "results/" + image.GetName() + "_" + suffix + ".ppm";
    result.Save(path);
}

static void PipeLineOld(Image image, Logger logger) {
    ImageProcessor processor = new ImageProcessor("Old", logger);
    processor.AddFilter(new BlurFilter(1));
    processor.AddFilter(new ContrastFilter(0.7f));
    processor.AddFilter(new SepiaFilter());
    processor.AddFilter(new GaussianNoiseFilter(0.03f));
    processor.AddFilter(new ContrastFilter(0.9f));
    Image result = processor.Process(image);
    string path = "results/" + image.GetName() + 
                  "_" + processor.GetName() + ".ppm";
    result.Save(path);
}

static void PipeLineVintage(Image image, Logger logger) {
    ImageProcessor processor = new ImageProcessor("Vintage", logger);
    processor.AddFilter(new ContrastFilter(0.8f));
    processor.AddFilter(new SepiaFilter());
    processor.AddFilter(new GaussianNoiseFilter(0.04f));
    processor.AddFilter(new BlurFilter(1));
    Image result = processor.Process(image);
    string path = "results/" + image.GetName() + 
                  "_" + processor.GetName() + ".ppm";
    result.Save(path);
}

static void Main()
{
    Logger logger = new Logger("results/log.txt");
    logger.Log("~~~~~~~~~~ Image Processing ~~~~~~~~~~");

    Image image = new Image("data/Lena.ppm");

    TestFilter(image, new GaussianNoiseFilter(0.5f),"gaussian");

    PipeLineOld(image, logger);
    PipeLineVintage(image, logger);

    logger.Close();
}

namespace ImageProcessing;

public class ImageProcessor
{
    private string name;
    private List<IImageFilter> filters;
    private Logger logger;

    public ImageProcessor(string name, Logger logger)
    {
        this.name = name;
        this.filters = new List<IImageFilter>();
        this.logger = logger;
    }

    public string GetName() { return name; }

    public void AddFilter(IImageFilter filter)
    {
        filters.Add(filter);
    }

    public Image Process(Image input)
    {
        Image current = input;
        logger.Log($"Processor: {name}");
        logger.Log($"Image: {input.GetName()}");

        foreach (var f in filters)
        {
            current = f.Apply(current);
            logger.Log(f.Description());
        }

        logger.Log("######################");
        return current;
    }
}

using System.IO;

namespace ImageProcessing;

public class Logger
{
    private StreamWriter writer;

    public Logger(string path)
    {
        writer = new StreamWriter(path);
    }

    public void Log(string message)
    {
        writer.WriteLine(message);
    }

    public void Close()
    {
        writer.Close();
    }
}

namespace ImageProcessing;

public interface IImageFilter
{
    Image Apply(Image input);
    string Description();
}

// Gray and Invert filters

public class ContrastFilter : IImageFilter
{
    private float factor;

    public ContrastFilter(float factor)
    {
        if (factor < 0)
            throw new ArgumentException("Factor must be >= 0");

        this.factor = factor;
    }

    public Image Apply(Image input)
    {
        int width = input.GetWidth();
        int height = input.GetHeight();
        string name = input.GetName();

        Image result = new Image(width, height, name);

        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                var c = input.GetPixel(x, y);

                float r = ApplyContrast(c.GetR());
                float g = ApplyContrast(c.GetG());
                float b = ApplyContrast(c.GetB());

                result.SetPixel(x, y, new Color(r, g, b));
            }
        }

        return result;
    }

    private float ApplyContrast(float v)
    {
        float res = (v - 0.5f) * factor + 0.5f;
        return Math.Clamp(res, 0f, 1f);
    }

    public string Description()
    {
        return $"Contrast(factor={factor})";
    }
}

public class SepiaFilter : IImageFilter
{
    public Image Apply(Image input)
    {
        int width = input.GetWidth();
        int height = input.GetHeight();
        string name = input.GetName();

        Image result = new Image(width, height, name);

        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                var c = input.GetPixel(x, y);

                float r = 0.393f * c.GetR() + 0.769f * c.GetG() + 0.189f * c.GetB();
                float g = 0.349f * c.GetR() + 0.686f * c.GetG() + 0.168f * c.GetB();
                float b = 0.272f * c.GetR() + 0.534f * c.GetG() + 0.131f * c.GetB();

                result.SetPixel(x, y, new Color(
                    Math.Clamp(r, 0f, 1f),
                    Math.Clamp(g, 0f, 1f),
                    Math.Clamp(b, 0f, 1f)
                ));
            }
        }

        return result;
    }

    public string Description()
    {
        return "Sepia";
    }
}

public class BlurFilter : IImageFilter
{
    private int radius;

    public BlurFilter(int radius)
    {
        if (radius < 1)
            throw new ArgumentException("Radius must be >= 1");

        this.radius = radius;
    }

    public Image Apply(Image input)
    {
        int width = input.GetWidth();
        int height = input.GetHeight();
        string name = input.GetName();

        Image result = new Image(width, height, name);

        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                float sumR = 0, sumG = 0, sumB = 0;
                int count = 0;

                for (int dy = -radius; dy <= radius; dy++)
                {
                    for (int dx = -radius; dx <= radius; dx++)
                    {
                        int nx = x + dx;
                        int ny = y + dy;

                        if (nx >= 0 && nx < width &&
                            ny >= 0 && ny < height)
                        {
                            var c = input.GetPixel(nx, ny);

                            sumR += c.GetR();
                            sumG += c.GetG();
                            sumB += c.GetB();

                            count++;
                        }
                    }
                }

                var blurred = new Color(
                    sumR / count,
                    sumG / count,
                    sumB / count
                );

                result.SetPixel(x, y, blurred);
            }
        }

        return result;
    }

    public string Description()
    {
        return $"Blur(radius={radius})";
    }
}

public class GaussianNoiseFilter : IImageFilter
{
    /*sigma = 0.03 → light
    sigma = 0.05 → perfect
    sigma = 0.1 → strong
    */
    private float sigma;
    private Random rand = new Random();

    public GaussianNoiseFilter(float sigma)
    {
        this.sigma = sigma;
    }

    public Image Apply(Image input)
    {
        int width = input.GetWidth();
        int height = input.GetHeight();
        string name = input.GetName();

        Image result = new Image(width, height, name);

        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                var c = input.GetPixel(x, y);

                float r = Math.Clamp(c.GetR() + Gaussian() * sigma, 0f, 1f);
                float g = Math.Clamp(c.GetG() + Gaussian() * sigma, 0f, 1f);
                float b = Math.Clamp(c.GetB() + Gaussian() * sigma, 0f, 1f);

                result.SetPixel(x, y, new Color(r, g, b));
            }
        }

        return result;
    }

    private float Gaussian()
    {
        double u1 = 1.0 - rand.NextDouble();
        double u2 = 1.0 - rand.NextDouble();

        double val =
            Math.Sqrt(-2.0 * Math.Log(u1)) *
            Math.Cos(2.0 * Math.PI * u2);

        return (float)val;
    }

    public string Description()
    {
        return $"GaussianNoise(sigma={sigma})";
    }
}