using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;

namespace aoc2018
{
    public class Day6
    {
        class Point
        {
            public int X, Y, Index, Dist;
            public char Char => (char) ('A' + Index);

            public static int Counter = 0;

            public Point(int _x, int _y)
            {
                X = _x;
                Y = _y;
                Index = Counter++;
            }

            public Point(int x1, int y1, int x2, int y2, int index)
            {
                Dist = Math.Abs(x1 - x2) + Math.Abs(y1 - y2);
                Index = index;
            }

            public Point(int index, int dist, bool notUsed)
            {
                Index = index;
                Dist = dist;
            }
        }

        public void Run()
        {
            var sw = Stopwatch.StartNew();
            // Part 1
            var s1 = Part1(1);
            var s2 = Part1(2);
            s2.RemoveAll(p2 => p2.Dist != s1.Single(p1 => p1.Char == p2.Char).Dist);
            sw.Stop();
            Console.WriteLine($"{s2.Max(x => x.Dist)} in {sw.ElapsedMilliseconds}ms");

            // Part 2
            Console.WriteLine(Part2(10000));
        }

        IEnumerable<Point> GetDistanceTo(IEnumerable<Point> points, int x, int y)
        {
            foreach (var p in points)
            {
                yield return new Point(p.X, p.Y, x, y, p.Index);
            }
        }

        List<Point> GetPoints(int margin)
        {
            Point.Counter = 0;

            return File.ReadAllLines("input\\day6input.txt")
                .Select(p => p.Split(new[] { ", " }, 2, StringSplitOptions.RemoveEmptyEntries))
                .Select(p => (int.Parse(p[0]), int.Parse(p[1])))
                .Select(p => new Point(margin + p.Item1, margin + p.Item2))
                .ToList();
        }

        List<Point> Part1(int margin)
        {
            var points = GetPoints(margin);
            var matrix = new char?[margin + points.Max(x => x.Y), margin + points.Max(x => x.X)];
            points.ForEach(x => matrix[x.Y, x.X] = x.Char);

            Fill();

            return points.Select(x => new Point(x.Index, Count(x), true)).ToList();

            int Count(Point p)
            {
                var r = 0;
                for (var i = 0; i < matrix.GetLength(0); i++)
                {
                    for (var j = 0; j < matrix.GetLength(1); j++)
                    {
                        if (matrix[i, j].GetValueOrDefault('.') == p.Char)
                        {
                            r++;
                        }
                    }
                }
                return r;
            }

            void Fill()
            {
                for (var i = 0; i < matrix.GetLength(0); i++)
                {
                    for (var j = 0; j < matrix.GetLength(1); j++)
                    {
                        if (matrix[i, j].HasValue)
                        {
                            continue;
                        }

                        var dist = GetDistanceTo(points, j, i).OrderBy(x => x.Dist).ToList();
                        var min = dist.First();
                        matrix[i, j] = dist.Count(x => x.Dist == min.Dist) == 1 ? min.Char : '.';
                    }
                }
            }
        }

        int Part2(int threshold)
        {
            var points = this.GetPoints(0);
            var r = 0;

            for (var i = 0; i < points.Max(x => x.Y); i++)
            {
                for (var j = 0; j < points.Max(x => x.X); j++)
                {
                    if (GetDistanceTo(points, j, i).Sum(x => x.Dist) < threshold)
                    {
                        r++;
                    }
                }
            }
            return r;
        }
    }
}