module ssa

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

struct FixedArrayZeroStats {
	instrs int
	geps   int
	stores int
}

fn build_ssa_for_fixed_array_zero_test(code string, native_bulk_zero bool) &Module {
	tmp_file := os.join_path(os.vtmp_dir(), 'v2_ssa_fixed_array_zero_${os.getpid()}.v')
	os.write_file(tmp_file, code) or { panic('failed to write temp file') }
	defer {
		os.rm(tmp_file) or {}
	}
	mut prefs := &vpref.Preferences{
		backend:     .x64
		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 trans := transformer.Transformer.new_with_pref(env, prefs)
	transformed := trans.transform_files(files)
	mut ssa_mod := Module.new('fixed_array_zero')
	mut b := Builder.new_with_env(ssa_mod, env)
	b.native_backend_bulk_zero_alloca = native_bulk_zero
	b.build_all(transformed)
	return ssa_mod
}

fn fixed_array_zero_stats(len int, native_bulk_zero bool) FixedArrayZeroStats {
	m := build_ssa_for_fixed_array_zero_test('
module main

fn main() {
	a := [${len}]u8{}
	_ = a
}
',
		native_bulk_zero)
	mut geps := 0
	mut stores := 0
	for instr in m.instrs {
		if instr.op == .get_element_ptr {
			geps++
		} else if instr.op == .store {
			stores++
		}
	}
	return FixedArrayZeroStats{
		instrs: m.instrs.len
		geps:   geps
		stores: stores
	}
}

fn test_empty_fixed_array_literal_emits_explicit_ssa_zero_stores() {
	small := fixed_array_zero_stats(16, false)
	large17 := fixed_array_zero_stats(17, false)
	large64 := fixed_array_zero_stats(64, false)

	assert small.geps >= 16
	assert small.stores >= 16
	assert large17.geps >= 17
	assert large17.stores >= 17
	assert large64.geps >= 64
	assert large64.stores >= 64
	assert large64.instrs > large17.instrs
}

fn test_native_bulk_zero_capable_backend_keeps_bounded_ssa_zero_stores() {
	small := fixed_array_zero_stats(16, true)
	large17 := fixed_array_zero_stats(17, true)
	large64 := fixed_array_zero_stats(64, true)

	assert small.geps >= 16
	assert small.stores >= 16
	assert large17.geps < small.geps
	assert large17.stores < small.stores
	assert large64.geps == large17.geps
	assert large64.stores == large17.stores
	assert large64.instrs <= large17.instrs + 4
}