import * as R from "remeda";

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

import V from '@yanick/vyktor';
import { createLogger } from "vite";

const readInput = (...args) =>
    R.pipe(
        readFile(...args),
        (lines) => lines.split("\n"),
        R.compact, // remove last line
        R.map(line => line.match(/x=-?.*?y=-?\d+/g).map(str =>
            str.match(/-?\d+/g).map(x => parseInt(x))).map(
                coords => V(coords)
            )
        ));

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

/** @returns [number,number][] */
export const mergeRanges = ( ranges ) =>  {

return    ranges.reduce( (accum,range) => {
        if( accum.length === 0 ) return [ range ];
        if( R.last( accum )[1] < range[0] ) {
            accum.push(range);
        }
        else {
            R.last(accum)[1] = Math.max( 
                R.last(accum)[1], range[1]
            )
        }
        return accum;
    }, [] );
}

export const spy = passthru( x => console.log(x) );

const entriesInRange = (targetLine,entries) => {

    entries = R.uniqBy(entries.map(([_,beacon])=>beacon).filter( beacon => beacon?.y === targetLine ), (x) => x.toString());

 return range => {
        return entries.filter(
            entry => (entry.x >= range[0]) && (entry.x <= range[1])
        ).length
    }
};

export const unbeaconAtLine = targetLine => entries => R.pipe(
    entries,
    R.map( ([x,y]) => [ x, x.manhattanDistance(y) ] ),
        R.filter(
e => (
            ( e[0].y - e[1] <= targetLine) &&
            ( e[0].y + e[1] >= targetLine) 
        ) 
        ),
        R.map(
            e => {
                const l = e[1] - Math.abs(targetLine - e[0].y);

                return [
        e[0].x - l,
        e[0].x + l ]
             }
        ),
    spy,
    (ranges) => 
        ranges.sort( (a,b) => {
            return (a[0] - b[0]) || (a[1]-b[1]);
        } )
    ,
    spy,
    mergeRanges,
    spy,
    R.sumBy( range => range[1] - range[0] + 1 - entriesInRange(targetLine,entries)(range) ) 
    );

export default unbeaconAtLine(2000000);