module build

import os

@[heap; noinit]
pub struct BuildContext {
mut:
	// should_run caches the result of should_run from tasks.
	should_run map[string]bool
	tasks      []Task
pub mut:
	// default is the default task to run when no others are provided.
	default ?string
}

@[heap; noinit]
pub struct Task {
	run        fn (Task) !     @[required]
	should_run fn (Task) !bool @[required]
	// repeatable controls whether or not this task can run multiple times per build cycle
	repeatable bool
pub:
	name    string
	help    string
	depends []string
mut:
	did_run bool
}

@[params]
pub struct BuildContextParams {
pub:
	default ?string
}

@[params]
pub struct TaskParams {
pub:
	name       string @[required]
	help       string
	depends    []string
	should_run fn (Task) !bool = |self| true
	run        fn (Task) ! @[required]
	// repeatable controls whether or not this task can run multiple times per build cycle
	repeatable bool
}

@[params]
pub struct ArtifactParams {
pub:
	name       string @[required]
	help       string
	depends    []string
	should_run fn (Task) !bool = |self| !os.exists(self.name)
	run        fn (Task) ! @[required]
	// repeatable controls whether or not this task can run multiple times per build cycle
	repeatable bool
}

// context creates an empty BuildContext.
pub fn context(params BuildContextParams) BuildContext {
	return BuildContext{
		default: params.default
	}
}

// task creates a task for the given context.
pub fn (mut context BuildContext) task(config TaskParams) {
	if context.get_task(config.name) != none {
		eprintln('error: task already exists with name `${config.name}`')
		exit(1)
	}
	context.tasks << Task{
		should_run: config.should_run
		run:        config.run
		name:       config.name
		help:       config.help
		depends:    config.depends
	}
}

// artifact creates an artifact task for the given context.
pub fn (mut context BuildContext) artifact(config ArtifactParams) {
	if context.get_task(config.name) != none {
		eprintln('error: task already exists with name `${config.name}`')
		exit(1)
	}
	context.tasks << Task{
		should_run: config.should_run
		run:        config.run
		name:       config.name
		help:       config.help
		depends:    config.depends
		repeatable: config.repeatable
	}
}

// get_task gets the task with the given name.
pub fn (mut context BuildContext) get_task(name string) ?&Task {
	for mut task in context.tasks {
		if task.name == name {
			return mut task
		}
	}
	return none
}

// exec executes the task with the given name in the context.
pub fn (mut context BuildContext) exec(name string) {
	if mut task := context.get_task(name) {
		task.exec(mut context)
	} else {
		eprintln('error: no such task: ${name}')
		exit(1)
	}
}

// exec runs the given task and its dependencies.
pub fn (mut task Task) exec(mut context BuildContext) {
	if task.did_run && !task.repeatable {
		println(': ${task.name} (skipped)')
		return
	}

	if task.name !in context.should_run {
		context.should_run[task.name] = task.should_run(task) or {
			eprintln('error: failed to call should_run for task `${task.name}`: ${err}')
			exit(1)
		}
	}

	if !context.should_run[task.name] {
		println(': ${task.name} (skipped)')
		return
	}

	for dep in task.depends {
		if dep == task.name {
			eprintln('error: cyclic task dependency detected, `${task.name}` depends on itself')
			exit(1)
		}

		context.exec(dep)
	}
	println(': ${task.name}')
	task.did_run = true
	task.run(task) or {
		eprintln('error: failed to run task `${task.name}`: ${err}')
		exit(1)
	}
}

// run executes all tasks provided through os.args.
pub fn (mut context BuildContext) run() {
	// filter out options
	mut tasks := os.args[1..].filter(|it| !it.starts_with('-'))

	// check options
	if '--tasks' in os.args || '-tasks' in os.args {
		println('Tasks:')
		for _, task in context.tasks {
			println('- ${task.name}: ${task.help}')
		}
		return
	}

	if tasks.len == 0 {
		if context.default != none {
			tasks << context.default
		} else {
			eprintln('error: no task provided, run with `--tasks` for a list')
			exit(1)
		}
	}

	// execute tasks
	for arg in tasks {
		context.exec(arg)
	}
}