package main

import "core:math"
import "core:slice"
import "core:strconv"
import "core:strings"
import "core:bytes"
import "core:fmt"
import "core:os"

import "../util"

PREAMBLE_LEN :: 25 

is_sum_of_two :: proc(target_number: i64, numbers: []i64) -> bool {
    for num1, idx in numbers {
        for num2 in numbers[idx+1:] {
            if num1 + num2 == target_number do return true
        }
    }

    return false
}

part_1 :: proc(lines: []string) {
    result: i64 = 0
    
    numbers := make([]i64, len(lines))

    for line, idx in lines {
        ok: bool
        numbers[idx], ok = strconv.parse_i64(line); assert(ok)
    }

    idx := PREAMBLE_LEN
    for number in numbers[PREAMBLE_LEN:] { 
        if !is_sum_of_two(number, numbers[idx-PREAMBLE_LEN:idx]) {
            result = number
            break
        }
        idx += 1
    }

    fmt.printfln("Part 1: %d", result)
}

part_2 :: proc(lines: []string) {
    result: i64 = 0
    
    numbers := make([]i64, len(lines))

    for line, idx in lines {
        ok: bool
        numbers[idx], ok = strconv.parse_i64(line); assert(ok)
    }

    invalid_number: i64
    idx := PREAMBLE_LEN
    for number in numbers[PREAMBLE_LEN:] { 
        if !is_sum_of_two(number, numbers[idx-PREAMBLE_LEN:idx]) {
            invalid_number = number
            break
        }
        idx += 1
    }

    min_idx: i64 = 0
    max_idx: i64 = 0
    outer: for _ in numbers {
        contiguous_sum: i64 = 0
        max_idx = min_idx
        for num in numbers[min_idx:] {
            contiguous_sum += num
            if contiguous_sum == invalid_number {
                max := slice.max(numbers[min_idx:max_idx+1])
                min := slice.min(numbers[min_idx:max_idx+1])
                result = max + min
                break outer
            } else if contiguous_sum > invalid_number {
                break
            }
            max_idx += 1
        }
        min_idx += 1
    }
    

    fmt.printfln("Part 2: %d", result)
}

main :: proc() {
    context.allocator = context.temp_allocator
    defer free_all(context.temp_allocator)

    INPUT :: #load("input.txt", string)
    lines := strings.split(INPUT, "\n")
    lines = lines[:len(lines)-1]

    part_1(lines)
    part_2(lines)
}