package internal

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"time"

	"github.com/cupcakearmy/autorestic/internal/lock"
	"github.com/robfig/cron"
)

type HookArray = []string

type Hooks struct {
	Before HookArray `mapstructure:"before"`
	After  HookArray `mapstructure:"after"`
}

type Options map[string]map[string][]string

type Location struct {
	Name    string   `mapstructure:"name"`
	From    string   `mapstructure:"from"`
	To      []string `mapstructure:"to"`
	Hooks   Hooks    `mapstructure:"hooks"`
	Cron    string   `mapstructure:"cron"`
	Options Options  `mapstructure:"options"`
}

func GetLocation(name string) (Location, bool) {
	c := GetConfig()
	for _, b := range c.Locations {
		if b.Name == name {
			return b, true
		}
	}
	return Location{}, false
}

func (l Location) validate(c Config) error {
	// Check if backends are all valid
	for _, to := range l.To {
		_, ok := GetBackend(to)
		if !ok {
			return fmt.Errorf("invalid backend `%s`", to)
		}
	}
	return nil
}

func (l Location) getOptions(key string) []string {
	var options []string
	saved := l.Options[key]
	for k, values := range saved {
		for _, value := range values {
			options = append(options, fmt.Sprintf("--%s", k), value)
		}
	}
	return options
}

func ExecuteHooks(commands []string, options ExecuteOptions) error {
	for _, command := range commands {
		out, err := ExecuteCommand(options, "-c", command)
		fmt.Println(out)
		return err
	}
	return nil
}

func (l Location) forEachBackend(fn func(ExecuteOptions) error) error {
	from, err := GetPathRelativeToConfig(l.From)
	if err != nil {
		return err
	}
	for _, to := range l.To {
		backend, _ := GetBackend(to)
		env, err := backend.getEnv()
		if err != nil {
			return nil
		}
		options := ExecuteOptions{
			Command: "bash",
			Envs:    env,
			Dir:     from,
		}
		if err := fn(options); err != nil {
			return err
		}
	}
	return nil
}

func (l Location) Backup() error {
	return l.forEachBackend(func(options ExecuteOptions) error {
		if err := ExecuteHooks(l.Hooks.Before, options); err != nil {
			return nil
		}

		flags := l.getOptions("backup")
		cmd := []string{"backup"}
		cmd = append(cmd, flags...)
		cmd = append(cmd, ".")
		out, err := ExecuteResticCommand(options, cmd...)
		fmt.Println(out)
		if err != nil {
			return err
		}

		if err := ExecuteHooks(l.Hooks.After, options); err != nil {
			return nil
		}
		return nil
	})
}

func (l Location) Forget(prune bool, dry bool) error {
	return l.forEachBackend(func(options ExecuteOptions) error {
		flags := l.getOptions("forget")
		cmd := []string{"forget", "--path", options.Dir}
		if prune {
			cmd = append(cmd, "--prune")
		}
		if dry {
			cmd = append(cmd, "--dry-run")
		}
		cmd = append(cmd, flags...)
		out, err := ExecuteResticCommand(options, cmd...)
		fmt.Println(out)
		if err != nil {
			return err
		}
		return nil
	})
}

func (l Location) hasBackend(backend string) bool {
	for _, b := range l.To {
		if b == backend {
			return true
		}
	}
	return false
}

func (l Location) Restore(to, from string, force bool) error {
	if from == "" {
		from = l.To[0]
	} else if !l.hasBackend(from) {
		return fmt.Errorf("invalid backend: \"%s\"", from)
	}

	to, err := filepath.Abs(to)
	if err != nil {
		return err
	}
	fmt.Printf("Restoring location to %s using %s.\n", to, from)

	// Check if target is empty
	if !force {
		notEmptyError := fmt.Errorf("target %s is not empty", to)
		_, err = os.Stat(to)
		if err == nil {
			files, err := ioutil.ReadDir(to)
			if err != nil {
				return err
			}
			if len(files) > 0 {
				return notEmptyError
			}
		} else {
			if !os.IsNotExist(err) {
				return err
			}
		}
	}

	backend, _ := GetBackend(from)
	resolved, err := GetPathRelativeToConfig(l.From)
	if err != nil {
		return nil
	}
	err = backend.Exec([]string{"restore", "--target", to, "--path", resolved, "latest"})
	if err != nil {
		return err
	}
	return nil
}

func (l Location) RunCron() error {
	if l.Cron == "" {
		return nil
	}

	schedule, err := cron.ParseStandard(l.Cron)
	if err != nil {
		return err
	}
	last := lock.GetCron("test")
	fmt.Println(last)
	next := schedule.Next(time.Unix(last, 0))
	fmt.Println(next)
	now := time.Now()
	if now.After(next) {
		fmt.Println("Running")
		lock.SetCron("test", now.Unix())
	} else {
		fmt.Println("Not due yet")
	}
	return nil
}