using System;

using System.Collections.Generic;

using System.Linq;

​

namespace AdventOfCode2022.Days

{

    public class Program

    {

        public static void Main()

        {

            string test20 = "1\r\n2\r\n-3\r\n3\r\n-2\r\n0\r\n4";

            Console.WriteLine(Day20.SumOfCoords(test20));

        }

    }

​

    internal class Day20

    {

        public static int SumOfCoords(string input)

        {

            // parse the input

​

            int[] numbers = input.Split("\r\n").Select(n => Int32.Parse(n)).ToArray();

​

            int len = numbers.Length;

​

            int mod = len - 1;

​

            // create a list to store the nodes in and fill it up

​

            List<ListNode> nodes = new();

​

            for (int i = 0; i < len; i++)

            {

                var num = numbers[i];

                nodes.Add(new(num, null, null, i));

            }

​

            for (int i = 0; i < len; i++)

            {

                nodes[i].Prev = i != 0 ? nodes[i - 1] : nodes[^1];

                nodes[i].Next = i != mod ? nodes[i + 1] : nodes[0];

            }

​

            // store the original indices 

​

            Dictionary<int, ListNode> indices = nodes.ToDictionary(n => n.Index, n => n);

​

            // loop over the original list and move each node by the amount contained in it

​

            for (int i = 0; i < len; i++)

            {

                ListNode node = indices[i];

​

                if (node.Value % mod == 0)

                {

                    continue;

                }

​

                ListNode.Move(ref node, node.Value);

            }

​

            //foreach (var node in nodes)

            //{

            //    Console.WriteLine($"Node {node.Value} is preceded by {node.Prev.Value}, and followed by {node.Next.Value}");

            //}

​

            // find the node with 0 and compute the sum

​

            var zero = nodes.First(n => n.Value == 0);

​

            int sum = 0;

​

            sum += zero.Traverse(1000).Value;

​

            sum += zero.Traverse(2000).Value;

​

            sum += zero.Traverse(3000).Value;

​

            return sum;

        }

    }

​

    // class to represent a doubly linked list

    internal class ListNode

    {

        public int Value { get; }

        public ListNode? Prev { get; set; }

        public ListNode? Next { get; set; } 

​

        public int Index { get; }

​

        // move through the list by the given distance

        public ListNode Traverse(int distance)

        {

            ListNode cur = this;

​

            for (int i = 0; i < distance; i++)

            {

                cur = cur.Next;

            }

​

            return cur;

        }

​

        // move a node by the (signed) distance

        public static void Move(ref ListNode node, int distance)

        {

            var cur = node;

​

            if (distance == 0)

            {

                return;

            }

            else if (distance < 0)

            {

                for (int i = 0; i > distance; i--)

                {

                    cur = cur.Prev;

                }

​

                node.Prev.Next = node.Next;

                node.Next.Prev = node.Prev;

​

                node.Prev = cur.Prev;

                node.Next = cur;

​

                cur.Prev.Next = node;

                cur.Prev = node;

            }

            else if (distance > 0)

            {

                for (int i = 0; i < distance; i++)

                {

                    cur = cur.Next;

                }

​

                node.Prev.Next = node.Next;

                node.Next.Prev = node.Prev;

​

                node.Prev = cur;

                node.Next = cur.Next;

​

                cur.Next.Prev = node;

                cur.Next = node;

            }

        }

​

        public ListNode(int value, ListNode? prev, ListNode? next, int index)

        {

            Prev = prev;

            Next = next;

            Value = value;

            Index = index;

        }

    }

}

​

​