#include "common.h"

static int
issafe(int *lvs, int n, int skip)
{
	int safe=1, asc=0,prev=0, ns=0,i;

	for (i=0; safe && i<n; i++) {
		if (i == skip)
			{ ns = 1; continue; }
		if (i-ns > 0)
			safe = safe && lvs[i] != prev &&
			    lvs[i] > prev-4 && lvs[i] < prev+4;
		if (i-ns == 1)
			asc = lvs[i] > prev;
		if (i-ns > 1)
			safe = safe && (lvs[i] > prev) == asc;

		prev = lvs[i];
	}

	return safe;
}

int
main(int argc, const char **argv)
{
	char buf[64], *rest, *tok;
	int p1=0,p2=0, lvs[16],n=0, i;

	if (argc > 1)
		DISCARD(freopen(argv[1], "r", stdin));

	while ((rest = fgets(buf, sizeof(buf), stdin))) {
		for (n=0; (tok = strsep(&rest, " ")); n++) {
			assert(n < (int)LEN(lvs));
			lvs[n] = (int)strtol(tok, NULL, 10);
		}

		for (i=-1; i<n; i++)
			if (issafe(lvs, n, i))
				{ p1 += i == -1; p2++; break; }
	}

	printf("02: %d %d\n", p1, p2);
}

import { AdventOfCodeSolutionFunction } from "./solutions";


/**
 * this function evaluates the 
 * @param levels a list to check
 * @returns -1 if there is no errors, or the index of where there's an unsafe event
 */
export function EvaluateLineSafe(levels: Array<number>) {
    // this loop is the checking every number in the line
    let isIncreasing: boolean | null = null;
    for (let levelIndex = 1; levelIndex < levels.length; levelIndex++) {
        const prevLevel = levels[levelIndex - 1]; // previous
        const level = levels[levelIndex]; // current
        const diff = level - prevLevel; // difference
        const absDiff = Math.abs(diff); // absolute difference

        // check if increasing too much or not at all
        if (absDiff == 0 || absDiff > 3)
            return levelIndex; // go to the next report

        // set increasing if needed
        if (isIncreasing === null) {
            isIncreasing = diff > 0;
            continue; // compare the next numbers
        }

        //  check if increasing then decreasing 
        if (!(isIncreasing && diff > 0 || !isIncreasing && diff < 0))
            return levelIndex; // go to the next report
    }

    return -1;
}


export const solution_2: AdventOfCodeSolutionFunction = (input) => {
    const reports = input.split("\n");

    let safe = 0;
    let safe_damp = 0;

    // this loop is for every line
    main: for (let i = 0; i < reports.length; i++) {
        const report = reports[i].trim();
        if (!report)
            continue; // report is empty

        const levels = report.split(" ").map((v) => Number(v));

        const evaluation = EvaluateLineSafe(levels);
        if(evaluation == -1) {
            safe++;
            continue;
        }
        
        // search around where it failed
        for (let offset = evaluation - 2; offset <= evaluation + 2; offset++) {
            // delete an evaluation in accordance to the offset
            let newLevels = [...levels];
            newLevels.splice(offset, 1);
            const newEval = EvaluateLineSafe(newLevels);
            if(newEval == -1) {
                safe_damp++;
                continue main;
            }
        }
    }

    return `Part 1: ${safe} Part 2: ${safe + safe_damp}`;
}