using System;
using System.Collections.Generic;
using System.Data.Common;
using System.IO;
using System.Linq;
using AdvenOfCode.Contracts;
using Coordinate = (int x, int y, int z);

namespace AoC_2025;

public class Day08
{
    private Coordinate[] ParsePuzzleInput(string path)
    {
        var puzzleInput = File.ReadAllLines(path)
            .Where(line => !string.IsNullOrWhiteSpace(line))
            .Select(line => line.Split(',', StringSplitOptions.RemoveEmptyEntries).Select(str => int.Parse(str)).ToArray())
            .Select(numbers => (numbers[0], numbers[1], numbers[2]))
            .ToArray();
        return puzzleInput;
    }

    public long SolvePart1(string pathToPuzzleInput, int amountToConnect)
    {
        var points = ParsePuzzleInput(pathToPuzzleInput);

        var pointPairs = GetAllCombinationsSortedByDistance(points);

        var circuits = CombineCircuits(amountToConnect, points, pointPairs);

        return circuits
            .Select(circuit => circuit.Count)
            .OrderDescending()
            .Take(3)
            .Aggregate((acc, next) => acc * next);
    }

    public long SolvePart2(string pathToPuzzleInput)
    {
        var points = ParsePuzzleInput(pathToPuzzleInput);

        var pointPairs = GetAllCombinationsSortedByDistance(points);

        var lastConnected = LastCombinedConnectAllCircuits(points, pointPairs);

        return lastConnected.a.x * lastConnected.b.x;
    }
    
    private List<List<Coordinate>> CombineCircuits(int amountToConnect, Coordinate[] points,
        (Coordinate pointA, Coordinate pointB)[] pointPairs)
    {
        var circuits = points.Select(p => new List<Coordinate>() { p }).ToList();
        for (var i = 0; i < amountToConnect; i++)
        {
            var nextToConnect = pointPairs[i];
            circuits = AddToCircuits(nextToConnect.pointA, nextToConnect.pointB, circuits);
        }

        return circuits;
    }

    private (Coordinate a, Coordinate b) LastCombinedConnectAllCircuits(Coordinate[] points,
        (Coordinate pointA, Coordinate pointB)[] pointPairs)
    {
        var circuits = points.Select(p => new List<Coordinate>() { p }).ToList();
        var lastConnected = pointPairs.First();
        var i = 0;
        while(circuits.Count > 1)
        {
            var nextToConnect = pointPairs[i++];
            circuits = AddToCircuits(nextToConnect.pointA, nextToConnect.pointB, circuits);
            lastConnected = nextToConnect;
        }

        return lastConnected;
    }

    private double GetDistance(Coordinate a, Coordinate b)
    {
        return Math.Sqrt(Math.Pow(a.x - b.x, 2) + Math.Pow(a.y - b.y, 2) + Math.Pow(a.z - b.z, 2));
    }

    private List<List<Coordinate>> AddToCircuits(Coordinate a, Coordinate b, List<List<Coordinate>> circuits)
    {
        var circuitToAddBTo = circuits.First(circuit => circuit.Contains(a));
        var circuitToAddATo = circuits.First(circuit => circuit.Contains(b));

        if (circuitToAddATo == circuitToAddBTo)
        {
            return circuits;
        }

        circuitToAddBTo.AddRange(circuitToAddATo);
        circuits.Remove(circuitToAddATo);
        return circuits;
    }

    private (Coordinate pointA, Coordinate pointB)[] GetAllCombinationsSortedByDistance(Coordinate[] coordinates)
    {
        var combinations = Combinations(coordinates)
            .OrderBy(x => GetDistance(x.a, x.b))
            .ToArray();
        return combinations;
    }

    private IEnumerable<(TValue a, TValue b)> Combinations<TValue>(IEnumerable<TValue> values) where TValue:IComparable
    {
        var enumeratedValues = values.Index().ToArray();
        var pairs = 
            from a in enumeratedValues
            from b in enumeratedValues
            where a.Index < b.Index
            select (a.Item, b.Item);
        return pairs;
    }
}