// Copyright (c) 2023 l-m.dev. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module wasm

import v.ast
import v.token
import wasm

pub fn (mut g Gen) as_numtype(a wasm.ValType) wasm.NumType {
    if a in [.funcref_t, .externref_t, .v128_t] {
        g.w_error("as_numtype: called with '${a}'")
    }

    return unsafe { wasm.NumType(a) }
}

// unwraps int_literal to i64_t
pub fn (mut g Gen) get_wasm_type_int_literal(typ_ ast.Type) wasm.ValType {
    if typ_ == ast.int_literal_type_idx {
        return wasm.ValType.i64_t
    }
    return g.get_wasm_type(typ_)
}

// "Register size" types such as int, i64 and bool boil down to their WASM counterparts.
// Structures and unions are pointers, i32.
pub fn (mut g Gen) get_wasm_type(typ_ ast.Type) wasm.ValType {
    typ := ast.mktyp(typ_)
    if typ == ast.void_type_idx {
        g.w_error("get_wasm_type: called with 'void'")
    }
    if typ.is_ptr() || typ.is_pointer() {
        return wasm.ValType.i32_t
    }
    if typ in ast.number_type_idxs {
        return match typ {
            ast.isize_type_idx, ast.usize_type_idx, ast.i8_type_idx, ast.u8_type_idx,
            ast.char_type_idx, ast.rune_type_idx, ast.i16_type_idx, ast.u16_type_idx,
            ast.i32_type_idx, ast.u32_type_idx {
                wasm.ValType.i32_t
            }
            ast.int_type_idx {
                $if new_int ? && x64 {
                    wasm.ValType.i64_t
                } $else {
                    wasm.ValType.i32_t
                }
            }
            ast.i64_type_idx, ast.u64_type_idx {
                wasm.ValType.i64_t
            }
            ast.f32_type_idx {
                wasm.ValType.f32_t
            }
            ast.f64_type_idx {
                wasm.ValType.f64_t
            }
            else {
                wasm.ValType.i32_t
            }
        }
    }
    if typ == ast.bool_type_idx {
        return wasm.ValType.i32_t
    }
    ts := g.table.sym(typ)
    match ts.info {
        ast.Struct {
            g.pool.type_size(typ)
            return wasm.ValType.i32_t // pointer
        }
        ast.Alias {
            return g.get_wasm_type(ts.info.parent_type)
        }
        ast.ArrayFixed {
            return wasm.ValType.i32_t // pointer
        }
        ast.Enum {
            return g.get_wasm_type(ts.info.typ)
        }
        else {}
    }

    g.w_error("get_wasm_type: unreachable type '${*g.table.sym(typ)}' ${ts.info}")
}

pub fn (mut g Gen) infix_param_type(typ ast.Type, op token.Kind) {
    match typ {
        ast.string_type {
            g.handle_string_operation(op)
        }
        else {
            eprintln(*g.table.sym(typ))
            panic('unimplemented infix operation for type')
        }
    }
}

pub fn (mut g Gen) infix_from_typ(typ ast.Type, op token.Kind) {
    if g.is_param_type(typ) {
        g.infix_param_type(typ, op)
    } else {
        g.infix_numeric_type(typ, op)
    }
}

fn (mut g Gen) infix_numeric_type(typ ast.Type, op token.Kind) {
    wasm_typ := g.as_numtype(g.get_wasm_type(typ))

    // This adds two tiers of comparaison but is a lot cleaner
    match op {
        .plus, .minus, .mul, .div, .mod {
            g.emit_arithmetic_op(wasm_typ, typ, op)
        }
        .eq, .ne, .gt, .lt, .ge, .le {
            g.emit_comparison_op(wasm_typ, typ, op)
        }
        .xor, .pipe, .amp, .left_shift, .right_shift, .unsigned_right_shift {
            g.emit_bitwise_op(wasm_typ, typ, op)
        }
        else {
            g.w_error('bad infix: op `${op}`')
        }
    }
}

fn (mut g Gen) emit_arithmetic_op(wasm_typ wasm.NumType, typ ast.Type, op token.Kind) {
    match op {
        .plus { g.func.add(wasm_typ) }
        .minus { g.func.sub(wasm_typ) }
        .mul { g.func.mul(wasm_typ) }
        .div { g.func.div(wasm_typ, typ.is_signed()) }
        .mod { g.func.rem(wasm_typ, typ.is_signed()) }
        else { g.w_error('invalid aritmetic op: `${op}`') }
    }
}

fn (mut g Gen) emit_comparison_op(wasm_typ wasm.NumType, typ ast.Type, op token.Kind) {
    is_signed := typ.is_signed()
    match op {
        .eq { g.func.eq(wasm_typ) }
        .ne { g.func.ne(wasm_typ) }
        .gt { g.func.gt(wasm_typ, is_signed) }
        .lt { g.func.lt(wasm_typ, is_signed) }
        .ge { g.func.ge(wasm_typ, is_signed) }
        .le { g.func.le(wasm_typ, is_signed) }
        else { g.w_error('invalid comparison op: `${op}`') }
    }
}

fn (mut g Gen) emit_bitwise_op(wasm_typ wasm.NumType, _typ ast.Type, op token.Kind) {
    match op {
        .xor { g.func.b_xor(wasm_typ) }
        .pipe { g.func.b_or(wasm_typ) }
        .amp { g.func.b_and(wasm_typ) }
        .left_shift { g.func.b_shl(wasm_typ) }
        .right_shift { g.func.b_shr(wasm_typ, true) }
        .unsigned_right_shift { g.func.b_shr(wasm_typ, false) }
        else { g.w_error('invalid bitwise op: `${op}`') }
    }
}