using System.Collections.Generic;
using System.IO;
using System.Linq;
using AdvenOfCode.Contracts;

namespace AoC_2025;

public class Day06 : IPuzzleSolver<long>
{
    private (string[] operands, string[] numberLines) ParsePuzzleInput(string path)
    {
        var puzzleInput = File.ReadAllLines(path)
            .Where(line => !string.IsNullOrWhiteSpace(line))
            .ToArray();
        var operands = puzzleInput[^1]
            .Split(' ', StringSplitOptions.RemoveEmptyEntries);
        var numbers = puzzleInput[..^1];
        return (operands, numbers);
    }

    public long SolvePart1(string pathToPuzzleInput)
    {
        var calculations = ParsePuzzleInput(pathToPuzzleInput);
        var numbers = ParseNumbersByWhitespace(calculations.numberLines);
        var operands = ParseOperands(calculations.operands);
        var results = CalculateResults(operands, numbers);
        return results.Sum();
    }
    
    public long SolvePart2(string pathToPuzzleInput)
    {
        var calculations = ParsePuzzleInput(pathToPuzzleInput);
        var operands = ParseOperands(calculations.operands);
        var numbers = ParseNumbersByColumn(calculations.numberLines);
        var results = CalculateResults(operands, numbers);

        return results.Sum();
    }

    private static long[] CalculateResults((Func<long, long, long> operation, long opBaseValue)[] operands, long[][] numbers)
    {
        return operands
            .Select((op, i) => numbers[i].Aggregate(op.opBaseValue, (acc, next) => op.operation(acc, next)))
            .ToArray();
    }

    private (Func<long, long, long> operation, long opBaseValue)[] ParseOperands(string[] operands)
    {
        var parsedOperands = operands
            .Select(ParseOperand)
            .ToArray();
        return parsedOperands;
    }

    private static long[][] ParseNumbersByWhitespace(string[] numbers)
    {
        var parsedNumbers = numbers
            .Select(line => line.Split(' ', StringSplitOptions.RemoveEmptyEntries))
            .SelectMany(line => line.Select(long.Parse).Index())
            .GroupBy(indexedNumber => indexedNumber.Index)
            .Select(group => group.Select(indexedNumber => indexedNumber.Item).ToArray())
            .ToArray();
        return parsedNumbers;
    }

    private static long[][] ParseNumbersByColumn(string[] numberLines)
    {
        List<long[]> numberColumns = [];
        List<long> currentColumn = [];
        for (var i = 1; i <= numberLines[0].Length; i++)
        {
            var nextNumber = numberLines.Aggregate("", (acc, numberLine) => acc + numberLine[^i]);

            if (!string.IsNullOrWhiteSpace(nextNumber))
            {
                currentColumn.Add(long.Parse(nextNumber));
            }
            else
            {
                numberColumns.Add(currentColumn.ToArray());
                currentColumn = [];
            }
        }
        numberColumns.Add(currentColumn.ToArray());
        
        numberColumns.Reverse();
        return numberColumns.ToArray();
    }

    private (Func<long, long, long> operation, long opBaseValue) ParseOperand(string operand) => operand switch
    {
        "+" => ((long a, long b) => a + b, 0),
        "*" => ((long a, long b) => a * b, 1),
        _ => throw new ArgumentOutOfRangeException(nameof(operand))
    };
}