using System;

using System.Collections.Generic;

using System.Linq;

using NUnit.Framework;

​

namespace AdventOfCode2020

{

    [TestFixture(TestName = "Day 14: Docking Data")]

    public static class Day14

    {

        public static void Main()

        {

            var result = Part2(TestInput);

            Console.WriteLine("Result: " + result);

        }

        private sealed record MemCell(string Address, long Value);

​

        private static string ApplyMask(long addr, in string mask)

        {

            var addrStr = new char[36];

            for (var i = 0; i < 36; i++)

            {

                var idx = 35 - i;

                addrStr[idx] = (addr & 1) == 1 ? '1' : '0';

                addr >>= 1;

                if (mask[idx] != '0')

                    addrStr[idx] = mask[idx];

            }

            return new(addrStr);

        }

​

        private static bool HasUniqueFloatingBits(in ReadOnlySpan<char> cellAddr, in ReadOnlySpan<char> valAddr)

        {

            var hasUniqueFloatingBits = false;

            for (var idx = 0; idx < 36; idx++)

                if (cellAddr[idx] != valAddr[idx] && valAddr[idx] != 'X')

                {

                    hasUniqueFloatingBits = true;

                    break;

                }

            return hasUniqueFloatingBits;

        }

​

        private static bool DoIntersect(in ReadOnlySpan<char> addr1, in ReadOnlySpan<char> addr2)

        {

            for (var i = 0; i < 36; i++)

            {

                if (addr1[i] == '0' && addr2[i] == '1'

                    || addr1[i] == '1' && addr2[i] == '0')

                    return false;

            }

            return true;

        }

​

        private static List<MemCell> Apply(this List<MemCell> list, in MemCell val)

        {

            var result = new HashSet<MemCell>(list.Count);

            foreach (var cell in list)

            {

                if (cell.Address == val.Address)

                {

                    if (val.Value != 0)

                        result.Add(val);

                }

                else if (DoIntersect(cell.Address, val.Address))

                {

                    var untouched = true;

                    var cellAddr = cell.Address.ToCharArray();

                    for (var i = 0; i < 36; i++)

                    {

                        if (cellAddr[i] != 'X' || val.Address[i] == 'X')

                            continue;

                        untouched = false;

                        var newAddr = (char[])cellAddr.Clone();

                        if (val.Address[i] == '0')

                        {

                            newAddr[i] = '1';

                            cellAddr[i] = '0';

                        }

                        else

                        {

                            newAddr[i] = '0';

                            cellAddr[i] = '1';

                        }

                        if (HasUniqueFloatingBits(newAddr, val.Address))

                            result.Add(new(new(newAddr), cell.Value));

                    }

                    if (untouched && HasUniqueFloatingBits(cell.Address, val.Address))

                        result.Add(cell);

                }

                else

                    result.Add(cell);

            }

            if (val.Value != 0)

                result.Add(val);

            var newResult = new List<MemCell>(result.OrderBy(v => v.Address));

​

            Console.WriteLine("".PadLeft(36, '-'));

            foreach (var cell in newResult)

                Console.WriteLine($"{cell.Address}: {cell.Value}");

​

            return newResult;

        }

        private static List<MemCell> ParseProgram2(in string input)

        {

            var result = new List<MemCell>();

            var mask = "".PadLeft(36, '0');

            foreach (var line in input.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries))

            {

                var parts = line.Split(" = ", StringSplitOptions.TrimEntries);

                if (parts[0] == "mask")

                    mask = parts[1];

                else

                {

                    var addr = long.Parse(parts[0][4..^1]);

                    var val = long.Parse(parts[1]);

                    var memCell = new MemCell(ApplyMask(addr, mask), val);

                    Console.WriteLine($"{Environment.NewLine}{memCell.Address} <- {memCell.Value}");

                    result = result.Apply(memCell);

                }

            }

            return result;

        }

​

        [TestCase(TestInput, ExpectedResult = (1L << 34)*101)]

        [TestCase(TestInput2, ExpectedResult = 208)]

        [TestCase(TestInput3, ExpectedResult = 1*3+2*4)]

        [TestCase(TestInput4, ExpectedResult = 1*2+2*4)]

        [TestCase(TestInput5, ExpectedResult = 1+2*2)]

        [TestCase(TestInput6, ExpectedResult = 1*2+2*2)]

        [TestCase(TestInput7, ExpectedResult = 1*2+2*2)]

        public static long Part2(in string input)

        {

            var mem = ParseProgram2(input);

            var result = 0L;

            foreach (var cell in mem)

            {

                var floatingBits = cell.Address.Count(c => c == 'X');

                result += (1L << floatingBits) * cell.Value;

            }

            return result;

        }

​

        private const string TestInput = @"

mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X

mem[8] = 11

mem[7] = 101

mem[8] = 0

";

        private const string TestInput2 = @"

mask = 000000000000000000000000000000X1001X

mem[42] = 100

mask = 00000000000000000000000000000000X0XX

mem[26] = 1

";

​

        private const string TestInput3 = @"

mask = 0000000000000000000000000000000000XX

mem[0] = 1

mask = 0000000000000000000000000000000XX000

mem[0] = 2

";

        private const string TestInput4 = @"

mask = 00000000000000000000000000000000001X

mem[0] = 1

mask = 0000000000000000000000000000000XX000

mem[0] = 2

";

        private const string TestInput5 = @"

mask = 00000000000000000000000000000000001X

mem[0] = 1

mask = 0000000000000000000000000000000000X0

mem[0] = 2

";

        private const string TestInput6 = @"

mask = 0000000000000000000000000000000000XX

mem[0] = 1

mask = 0000000000000000000000000000000000X0

mem[0] = 2

";

        private const string TestInput7 = @"

mask = 00000000000000000000000000000000X001

mem[0] = 1

mask = 0000000000000000000000000000000001X0

mem[0] = 2

";

    }

}