package space_worker

import (
	"bytes"
	"fmt"
	"os"
	"path/filepath"
	"playbookctl/internal/types"
	"playbookctl/internal/utils"
	"slices"
)

func (app *SpaceWorker) CreateRole(name string) error {
	app.log.Debug(fmt.Sprintf("workDir: %s", app.workDir))
	app.log.Debug(fmt.Sprintf("role name: %s", name))

	rolePath := filepath.Join(app.workDir, "roles", name)
	app.log.Debug(fmt.Sprintf("rolePath: %s", rolePath))

	app.log.Trace(fmt.Sprintf("try create '%s' dir", name))
	if err := os.Mkdir(rolePath, 0755); os.IsExist(err) {
		app.log.Warn(fmt.Sprintf("Папка \"%s\" уже существует", name))
		return nil
	}

	for _, dir := range []string{"defaults", "files", "tasks", "templates", "vars"} {
		app.log.Trace(fmt.Sprintf("try create %s/%s dir", name, dir))
		if err := utils.CreateDir(filepath.Join(rolePath, dir)); err != nil {
			return err
		}
	}

	for _, dir := range []string{"defaults", "vars"} {
		app.log.Trace(fmt.Sprintf("try create %s/%s/main.yml", name, dir))
		if err := utils.WriteEmptyYaml(filepath.Join(rolePath, dir, "main.yml")); err != nil {
			return err
		}
	}

	{ // tasks dir
		app.log.Trace("generate main task")
		if err := generateMainTask(name, rolePath, false); err != nil {
			return err
		}

		app.log.Trace("create install task")
		if err := utils.WriteEmptyYaml(filepath.Join(rolePath, "tasks", "install.yml")); err != nil {
			return err
		}
	}

	app.log.Trace("generate readme")
	if err := generateReadme(name, rolePath); err != nil {
		return err
	}

	app.log.Trace("read playbook.yml")
	playbook, err := types.ReadPlaybook(app.workDir)
	if err != nil {
		return err
	}

	app.log.Trace("append role to playbook.yml")
	playbook.Roles = append(playbook.Roles, name)

	app.log.Trace("write playbook.yml")
	if err := types.WritePlaybook(app.workDir, playbook); err != nil {
		return err
	}

	app.log.Info(fmt.Sprintf("Роль %s создана", name))
	return nil
}

func generateMainTask(name string, path string, withBackup bool) error {
	var mainTask []types.MainTask

	if withBackup {
		mainTask = make([]types.MainTask, 4)
	} else {
		mainTask = make([]types.MainTask, 1)
	}

	mainTask[0] = types.MainTask{
		IncludeTasks: "install.yml",
		When: fmt.Sprintf("(dd_install is defined and dd_install) "+
			"or (dd_install_%s is defined and dd_install_%s)", name, name),
	}

	if withBackup {
		mainTask[1] = types.MainTask{
			IncludeTasks: "backup.yml",
			When: fmt.Sprintf("(dd_backup is defined and dd_backup) "+
				"or (dd_backup_%s is defined and dd_backup_%s)", name, name),
		}

		mainTask[2] = types.MainTask{
			IncludeTasks: "pre-restore.yml",
			When: fmt.Sprintf("(dd_prerestore is defined and dd_prerestore) "+
				"or (dd_prerestore_%s is defined and dd_prerestore_%s)", name, name),
		}

		mainTask[3] = types.MainTask{
			IncludeTasks: "restore.yml",
			When: fmt.Sprintf("(dd_restore is defined and dd_restore) "+
				"or (dd_restore_%s is defined and dd_restore_%s)", name, name),
		}
	}

	return types.WriteMainTask(path, &mainTask)
}

func generateReadme(name string, path string) error {
	buffer := &bytes.Buffer{}

	buffer.WriteString(fmt.Sprintf("# %s\n\n", name))
	buffer.Write(staticReadme)

	return os.WriteFile(filepath.Join(path, "README.MD"), buffer.Bytes(), 0644)
}

func (app SpaceWorker) RemoveRole(name string) error {
	app.log.Debug(fmt.Sprintf("workDir: %s", app.workDir))
	app.log.Debug(fmt.Sprintf("role name: %s", name))

	rolePath := filepath.Join(app.workDir, "roles", name)
	app.log.Debug(fmt.Sprintf("rolePath: %s", rolePath))

	app.log.Trace(fmt.Sprintf("try remove '%s' dir", name))
	if err := os.RemoveAll(rolePath); err != nil {
		return err
	}

	app.log.Trace("read playbook.yml")
	playbook, err := types.ReadPlaybook(app.workDir)
	if err != nil {
		return err
	}

	app.log.Trace("remove role from playbook.yml")
	idx := slices.Index(playbook.Roles, name)
	if idx >= 0 {
		playbook.Roles = slices.Delete(playbook.Roles, idx, idx+1)
	}

	app.log.Trace("write playbook.yml")
	if err := types.WritePlaybook(app.workDir, playbook); err != nil {
		return err
	}

	app.log.Info(fmt.Sprintf("Роль %s удалена", name))
	return nil
}

func (app *SpaceWorker) ListRoles() error {
	app.log.Debug(fmt.Sprintf("workDir: %s", app.workDir))

	app.log.Trace("try read playbook.yml")
	playbook, err := types.ReadPlaybook(app.workDir)
	if err != nil {
		return err
	}

	fmt.Println("Доступные роли:")
	for _, roleName := range playbook.Roles {
		fmt.Printf(" - %s\n", roleName)
	}

	return nil
}

func (app *SpaceWorker) ModifyRoleBackupAdd(name string) error {
	app.log.Debug(fmt.Sprintf("workDir: %s", app.workDir))
	app.log.Debug(fmt.Sprintf("role name: %s", name))

	rolePath := filepath.Join(app.workDir, "roles", name)
	app.log.Debug(fmt.Sprintf("rolePath: %s", rolePath))

	for _, file := range []string{"backup.yml", "pre-restore.yml", "restore.yml"} {
		app.log.Trace(fmt.Sprintf("try create %s", file))
		if err := utils.WriteEmptyYaml(filepath.Join(rolePath, "tasks", file)); err != nil {
			return err
		}
	}

	app.log.Trace("re-generate main task")
	if err := generateMainTask(name, rolePath, true); err != nil {
		return err
	}

	app.log.Trace("try create backups dir")
	if err := utils.CreateDirIfNotExists(filepath.Join(rolePath, "backups")); err != nil {
		return err
	}

	app.log.Trace("create .gitignore")
	if err := utils.WriteStringFile(filepath.Join(rolePath, ".gitignore"), "backups/"); err != nil {
		return err
	}

	return nil
}