import * as R from "remeda";
import u from "updeep";

import Graph from 'graphology';
import { bidirectional } from 'graphology-shortest-path';

import { combinations, permutations } from "combinatorial-generators";

import { readFile } from "../05/part1.js";

const parseLine = (line) => {
    const { groups } = line.match(/Valve (?<valve>..).*flow rate=(?<flow>\d+).*valves? (?<exits>.*)/);
    return [groups.valve, {
        exits: groups.exits.split(',').map(x => x.trim()),
        flow: parseInt(groups.flow)
    }]
}
const readInput = (...args) =>
    R.pipe(
        readFile(...args),
        (lines) => lines.split("\n"),
        R.compact, // remove last line
        R.map(parseLine),
        Object.fromEntries,
    );

export const puzzleInput = readInput(import.meta.url, "input");
export const sample = readInput(import.meta.url, "sample");

function finalSteam(tunnels, graph, minutesLeft, possibilities, location = 'AA', activeSteam = 0) {
    //console.log(minutesLeft, totalSteam, itinary);

    if (minutesLeft <= 0) return 0;

    if (possibilities.length === 0) return minutesLeft * activeSteam;

    let scores = [];

    for ( const next of possibilities ) {
        const path = bidirectional(graph, location, next);
        
    //console.log(path);

    let time = path.length;
    if (time >= minutesLeft) {
            scores.push( minutesLeft * activeSteam );
    }
    else {
        //console.log({totalSteam, time, activeSteam});
        let ts = time * activeSteam;
        let as = activeSteam + tunnels[next].flow;

        scores.push(
                ts + finalSteam(
                    tunnels, graph, minutesLeft - time,
                    possibilities.filter( x => x !== next ),
                    next,
                    as
                )
        )
    }

    }

    return Math.max( ...scores );
}

export const buildGraph = tunnels => {
    const graph = new Graph();
    Object.keys(tunnels).forEach(x => graph.addNode(x));

    Object.entries(tunnels).forEach(([location, { exits }]) => {
        exits.forEach(exit => graph.addEdge(location, exit));
    });


    return graph;

};

export default (tunnels) => {

    const possibilities = 
        Object.keys(tunnels).filter(
            k => tunnels[k].flow
        );

    const graph = buildGraph(tunnels);

    return  finalSteam(tunnels, graph, 30, possibilities, 'AA', 0, 0)

};