errors.oc

//* Utilities for displaying errors

import std::vector::Vector
import std::span::Span
import std::mem
import std::fs

enum ErrorType {
    Standard
    WithNote
    WithHint
}

def ErrorType::str(this): str => match this {
    Standard => "Standard"
    WithNote => "WithNote"
    WithHint => "WithHint"
}

struct Error {
    type: ErrorType
    msg1: str
    span1: Span
    msg2: str
    span2: Span
}

enum MessageType {
    Error
    Warning
    Note
}

def MessageType::to_color(this): str => match this {
    Error => "\x1b[31m"
    Warning => "\x1b[33m"
    Note => "\x1b[32m"
}

def MessageType::str(this): str => match this {
    Error => "Error"
    Warning => "Warning"
    Note => "Note"
}

def display_line() {
    println("--------------------------------------------------------------------------------")
}

def display_message(type: MessageType, span: Span, msg: str) {
    display_line()
    let filename = span.start.filename
    if filename == "<default>" or span.start.line == 0 {
        println("%s: %s", type.str(), msg)
    } else {
        println("%s: %s: %s", span.start.str(), type.str(), msg)
    }
    display_line()
}

def display_message_span(type: MessageType, span: Span, msg: str, line_after: bool = true) {
    let color = MessageType::to_color(type)
    let reset = "\x1b[0m"

    display_message(type, span, msg)

    let filename = span.start.filename;
    if not fs::file_exists(filename) return

    let contents = fs::read_file(filename)
    defer contents.free()

    let around_offset = 1
    let min_line = (span.start.line - around_offset).max(1)
    let max_line = span.end.line + around_offset
    max_line = max_line.min(min_line + 10)  // Don't print more than 10 lines

    // TODO: Use SVs here instead of strsep
    let line_no = 1
    for line in contents.sv().lines() {
        if line_no > max_line break
        if line_no >= min_line {
            print(f"{line_no:4d} | ")
            if line_no == span.start.line {
                let start_col = span.start.col - 1
                let end_col = span.end.col - 1
                if span.end.line != span.start.line {
                    end_col = line.len
                }
                for let i = 0; i < start_col; i += 1 {
                    print(f"{line[i]}")
                }
                print(f"{color}")
                for let i = start_col; i < end_col; i += 1 {
                    print(f"{line[i]}")
                }
                let remaining_line = line.slice(end_col)
                println(f"{reset}{remaining_line}")
                println("%*s%s^ %s%s", start_col + 7, "", color, msg, reset)
            } else {
                println(f"{line}")
            }
        }
        line_no += 1
    }
    if line_after {
        display_line()
    }
}

def Error::display(&this) {
    match .type {
        Standard => {
            display_message_span(MessageType::Error, .span1, .msg1)
        }
        WithNote => {
            display_message_span(MessageType::Error, .span1, .msg1, line_after: false)
            display_message(MessageType::Note, .span1, .msg2)
        }
        WithHint => {
            display_message_span(MessageType::Error, .span1, .msg1, line_after: false)
            display_message_span(MessageType::Note, .span2, .msg2)
        }
    }
}

[exits]
def Error::panic(&this) {
    .display()
    std::exit(1)
}

def Error::new(span: Span, msg: str): &Error {
    let err = mem::alloc<Error>()
    err.type = ErrorType::Standard
    err.msg1 = msg
    err.span1 = span
    return err
}

def Error::new_note(span: Span, msg: str, note: str): &Error {
    let err = mem::alloc<Error>()
    err.type = ErrorType::WithNote
    err.msg1 = msg
    err.span1 = span
    err.msg2 = note
    return err
}

def Error::new_hint(span: Span, msg: str, span2: Span, hint: str): &Error {
    let err = mem::alloc<Error>()
    err.type = ErrorType::WithHint
    err.msg1 = msg
    err.span1 = span
    err.msg2 = hint
    err.span2 = span2
    return err
}

def display_error_messages(errors: &Vector<&Error>, detail_level: u32) {
    let num_errors_env = std::libc::getenv("OCEN_NUM_ERRORS")
    let max_num_errors = if num_errors_env? then num_errors_env.to_u32() else 10

    let num_errors = errors.size.min(max_num_errors)
    for let i = 0; i < num_errors; i += 1 {
        let err = errors.at(num_errors - i - 1)

        match detail_level {
            0 => println("%s: %s", err.span1.start.str(), err.msg1)
            1 => display_message_span(MessageType::Error, err.span1, err.msg1)
            2 => err.display()
            else => std::panic("invalid detail level")
        }
    }
}