module transformer

import os
import v2.ast
import v2.parser
import v2.pref as vpref
import v2.token
import v2.types

fn transform_fixed_array_slice_code_for_test(code string) []ast.File {
    tmp_file := os.join_path(os.temp_dir(), 'v2_transformer_fixed_slice_${os.getpid()}.v')
    os.write_file(tmp_file, code) or { panic('failed to write temp file') }
    defer {
        os.rm(tmp_file) or {}
    }
    prefs := &vpref.Preferences{
        backend:     .cleanc
        no_parallel: true
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files([tmp_file], mut file_set)
    mut env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut transformer := Transformer.new_with_pref(env, prefs)
    return transformer.transform_files(files)
}

fn count_fixed_slice_call_in_expr(expr ast.Expr, name string) int {
    match expr {
        ast.ArrayInitExpr {
            mut count := count_fixed_slice_call_in_expr(expr.typ, name)
            for item in expr.exprs {
                count += count_fixed_slice_call_in_expr(item, name)
            }
            count += count_fixed_slice_call_in_expr(expr.init, name)
            count += count_fixed_slice_call_in_expr(expr.cap, name)
            count += count_fixed_slice_call_in_expr(expr.len, name)
            count += count_fixed_slice_call_in_expr(expr.update_expr, name)
            return count
        }
        ast.CallExpr {
            mut count := if expr.lhs is ast.Ident && expr.lhs.name == name { 1 } else { 0 }
            count += count_fixed_slice_call_in_expr(expr.lhs, name)
            for arg in expr.args {
                count += count_fixed_slice_call_in_expr(arg, name)
            }
            return count
        }
        ast.CastExpr {
            return count_fixed_slice_call_in_expr(expr.typ, name) +
                count_fixed_slice_call_in_expr(expr.expr, name)
        }
        ast.IndexExpr {
            return count_fixed_slice_call_in_expr(expr.lhs, name) +
                count_fixed_slice_call_in_expr(expr.expr, name)
        }
        ast.InfixExpr {
            return count_fixed_slice_call_in_expr(expr.lhs, name) +
                count_fixed_slice_call_in_expr(expr.rhs, name)
        }
        ast.InitExpr {
            mut count := count_fixed_slice_call_in_expr(expr.typ, name)
            for field in expr.fields {
                count += count_fixed_slice_call_in_expr(field.value, name)
            }
            return count
        }
        ast.KeywordOperator {
            mut count := 0
            for value in expr.exprs {
                count += count_fixed_slice_call_in_expr(value, name)
            }
            return count
        }
        ast.MapInitExpr {
            mut count := count_fixed_slice_call_in_expr(expr.typ, name)
            for key in expr.keys {
                count += count_fixed_slice_call_in_expr(key, name)
            }
            for value in expr.vals {
                count += count_fixed_slice_call_in_expr(value, name)
            }
            return count
        }
        ast.ModifierExpr {
            return count_fixed_slice_call_in_expr(expr.expr, name)
        }
        ast.ParenExpr {
            return count_fixed_slice_call_in_expr(expr.expr, name)
        }
        ast.PrefixExpr {
            return count_fixed_slice_call_in_expr(expr.expr, name)
        }
        ast.RangeExpr {
            return count_fixed_slice_call_in_expr(expr.start, name) +
                count_fixed_slice_call_in_expr(expr.end, name)
        }
        ast.SelectorExpr {
            return count_fixed_slice_call_in_expr(expr.lhs, name)
        }
        ast.Tuple {
            mut count := 0
            for value in expr.exprs {
                count += count_fixed_slice_call_in_expr(value, name)
            }
            return count
        }
        ast.UnsafeExpr {
            return count_fixed_slice_call_in_stmts(expr.stmts, name)
        }
        else {
            return 0
        }
    }
}

fn count_fixed_slice_call_in_stmt(stmt ast.Stmt, name string) int {
    match stmt {
        ast.AssignStmt {
            mut count := 0
            for lhs in stmt.lhs {
                count += count_fixed_slice_call_in_expr(lhs, name)
            }
            for rhs in stmt.rhs {
                count += count_fixed_slice_call_in_expr(rhs, name)
            }
            return count
        }
        ast.ExprStmt {
            return count_fixed_slice_call_in_expr(stmt.expr, name)
        }
        else {
            return 0
        }
    }
}

fn count_fixed_slice_call_in_stmts(stmts []ast.Stmt, name string) int {
    mut count := 0
    for stmt in stmts {
        count += count_fixed_slice_call_in_stmt(stmt, name)
    }
    return count
}

fn transformed_fixed_slice_fn(files []ast.File, name string) ?ast.FnDecl {
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == name {
                return stmt
            }
        }
    }
    return none
}

fn test_fixed_array_slice_bounds_are_materialized_once() {
    files := transform_fixed_array_slice_code_for_test('
fn next() int {
    return 1
}

fn stop() int {
    return 3
}

fn main() {
    arr := [4]int{}
    part := arr[next()..stop()]
    _ = part
}
')
    main_decl := transformed_fixed_slice_fn(files, 'main') or {
        assert false, 'missing transformed main'
        return
    }

    assert count_fixed_slice_call_in_stmts(main_decl.stmts, 'next') == 1
    assert count_fixed_slice_call_in_stmts(main_decl.stmts, 'stop') == 1
    assert count_fixed_slice_call_in_stmts(main_decl.stmts, 'new_array_from_c_array') == 1
}