package day02;

import "core:os";
import "core:fmt";

Move :: enum {
    ROCK = 1,
    PAPER = 2,
    SCISSORS = 3,
}

rune_move : map[u8]Move

init :: proc () {
    rune_move := make(map[u8]Move)
    rune_move['A'] = Move.ROCK
    rune_move['X'] = Move.ROCK
    rune_move['B'] = Move.PAPER
    rune_move['Y'] = Move.PAPER
    rune_move['C'] = Move.SCISSORS
    rune_move['Z'] = Move.SCISSORS
}

determine_score :: proc(friendly: Move, enemy: Move) -> int {
    result: int;
    if enemy == friendly { 
        result = 3 
    } else if friendly == Move.ROCK && enemy == Move.PAPER {
        result = 0
    } else if friendly == Move.PAPER && enemy == Move.SCISSORS {
        result = 0
    } else if friendly == Move.SCISSORS && enemy == Move.ROCK {
        result = 0
    } else {
        result = 6
    }
    return result + int(friendly)
}

/// Scoring for Part 2 of the puzzle
determine_score_alt :: proc(outcome: Move, enemy: Move) -> int {
    // Redefine the outcomes so that
    // draw = 0, win = 1, lose = 2
    outcome_ : int;
    switch outcome {
        // X = lose
        case .ROCK:
            outcome_ = 2
        // Y = draw
        case .PAPER:
            outcome_ = 0
        // Z = win
        case .SCISSORS:
            outcome_ = 1
    }
    // Convert enemy from range [1, 3] to range [0, 2]
    enemy_ := int(enemy) - 1
    // Assert that (friendly - enemy = outcome) % 3 (see scratch.py)
    // Thus, (friendly = outcome + enemy) % 3
    friendly_ := (outcome_ + enemy_) % 3
    // Add 1 back in because we subtracted it before (going from [0, 2] to [1, 3])
    friendly_ = friendly_ + 1
    // Return score as before
    return determine_score(cast(Move)friendly_, enemy)
}

main :: proc () {
    init()
    if len(os.args) < 2 {
        fmt.printf("Usage: %s FILENAME\n", os.args[0])
        os.exit(-1)
    }
    
    fh, errno := os.open(os.args[1])
    if errno != os.ERROR_NONE {
        fmt.printf("Cannot open %s: %s\n", os.args[1], os.get_last_error_string())
        os.exit(-1)
    }
    defer os.close(fh)

    buffer: []u8 = make([]u8, 1);
    defer delete(buffer);

    num_read, error := os.read(fh, buffer)
    score : int = 0;
    total_score : int = 0;
    friendly : Move
    enemy : Move
    chr : u8

    for ; error == os.ERROR_NONE && num_read > 0; num_read, error = os.read(fh, buffer) {
        chr = buffer[0]
        switch chr {
            case '\n':
            score = determine_score_alt(friendly, enemy)
            fmt.printf("Score for this line: %d\n", score)
            total_score += score
            case 'A':
                enemy = .ROCK
            case 'B':
                enemy = .PAPER
            case 'C':
                enemy = .SCISSORS
            case 'X':
                friendly = .ROCK
            case 'Y':
                friendly = .PAPER
            case 'Z':
                friendly = .SCISSORS
            case:
                // this is the default
        }
    }
    if chr != '\n' {
        total_score += determine_score_alt(friendly, enemy)
    }
    /// Handle potential errors
    if error != os.ERROR_NONE {
        fmt.printf("Error reading file: %s", os.get_last_error_string())
        os.exit(-1)
    }
    delete(rune_move);
    fmt.printf("Your score is: %d\n", total_score)
}