package internal

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

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

type LocationType string

const (
	TypeLocal    LocationType = "local"
	TypeVolume   LocationType = "volume"
	VolumePrefix string       = "volume:"
)

type HookArray = []string

type Hooks struct {
	Before  HookArray `yaml:"before,omitempty"`
	After   HookArray `yaml:"after,omitempty"`
	Success HookArray `yaml:"success,omitempty"`
	Failure HookArray `yaml:"failure,omitempty"`
}

type Options map[string]map[string][]interface{}

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

func GetLocation(name string) (Location, bool) {
	l, ok := GetConfig().Locations[name]
	l.name = name
	return l, ok
}

func (l Location) validate() error {
	if l.From == "" {
		return fmt.Errorf(`Location "%s" is missing "from" key`, l.name)
	}
	if l.getType() == TypeLocal {
		if from, err := GetPathRelativeToConfig(l.From); err != nil {
			return err
		} else {
			if stat, err := os.Stat(from); err != nil {
				return err
			} else {
				if !stat.IsDir() {
					return fmt.Errorf("\"%s\" is not valid directory for location \"%s\"", from, l.name)
				}
			}
		}
	}

	if len(l.To) == 0 {
		return fmt.Errorf(`Location "%s" has no "to" targets`, l.name)
	}
	// 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 ExecuteHooks(commands []string, options ExecuteOptions) error {
	if len(commands) == 0 {
		return nil
	}
	colors.Secondary.Println("\nRunning hooks")
	for _, command := range commands {
		colors.Body.Println("> " + command)
		out, err := ExecuteCommand(options, "-c", command)
		if err != nil {
			colors.Error.Println(out)
			return err
		}
		if VERBOSE {
			colors.Faint.Println(out)
		}
	}
	colors.Body.Println("")
	return nil
}

func (l Location) getType() LocationType {
	if strings.HasPrefix(l.From, VolumePrefix) {
		return TypeVolume
	}
	return TypeLocal
}

func (l Location) getVolumeName() string {
	return strings.TrimPrefix(l.From, VolumePrefix)
}

func (l Location) getPath() (string, error) {
	t := l.getType()
	switch t {
	case TypeLocal:
		if path, err := GetPathRelativeToConfig(l.From); err != nil {
			return "", err
		} else {
			return path, nil
		}
	case TypeVolume:
		return "/volume/" + l.name + "/" + l.getVolumeName(), nil
	}
	return "", fmt.Errorf("could not get path for location \"%s\"", l.name)
}

func (l Location) Backup(cron bool) []error {
	var errors []error
	colors.PrimaryPrint("  Backing up location \"%s\"  ", l.name)
	t := l.getType()
	options := ExecuteOptions{
		Command: "bash",
		Envs: map[string]string{
			"AUTORESTIC_LOCATION": l.name,
		},
	}

	if err := l.validate(); err != nil {
		errors = append(errors, err)
		colors.Error.Print(err)
		goto after
	}

	if t == TypeLocal {
		dir, _ := GetPathRelativeToConfig(l.From)
		colors.Faint.Printf("Executing under: \"%s\"\n", dir)
		options.Dir = dir
	}

	// Hooks
	if err := ExecuteHooks(l.Hooks.Before, options); err != nil {
		errors = append(errors, err)
		goto after
	}

	// Backup
	for i, to := range l.To {
		backend, _ := GetBackend(to)
		colors.Secondary.Printf("Backend: %s\n", backend.name)
		env, err := backend.getEnv()
		if err != nil {
			errors = append(errors, err)
			continue
		}

		lFlags := getOptions(l.Options, "backup")
		bFlags := getOptions(backend.Options, "backup")
		cmd := []string{"backup"}
		cmd = append(cmd, lFlags...)
		cmd = append(cmd, bFlags...)
		if cron {
			cmd = append(cmd, "--tag", "cron")
		}
		cmd = append(cmd, ".")
		backupOptions := ExecuteOptions{
			Dir:  options.Dir,
			Envs: env,
		}

		var out string

		switch t {
		case TypeLocal:
			out, err = ExecuteResticCommand(backupOptions, cmd...)
		case TypeVolume:
			out, err = backend.ExecDocker(l, cmd)
		}
		if err != nil {
			colors.Error.Println(out)
			errors = append(errors, err)
			continue
		}

		md := metadata.ExtractMetadataFromBackupLog(out)
		mdEnv := metadata.MakeEnvFromMetadata(&md)
		for k, v := range mdEnv {
			options.Envs[k+"_"+fmt.Sprint(i)] = v
			options.Envs[k+"_"+strings.ToUpper(backend.name)] = v
		}
		if VERBOSE {
			colors.Faint.Println(out)
		}
	}

	// After hooks
	if err := ExecuteHooks(l.Hooks.After, options); err != nil {
		errors = append(errors, err)
	}

after:
	var commands []string
	if len(errors) > 0 {
		commands = l.Hooks.Failure
	} else {
		commands = l.Hooks.Success
	}
	if err := ExecuteHooks(commands, options); err != nil {
		errors = append(errors, err)
	}

	colors.Success.Println("Done")
	return errors
}

func (l Location) Forget(prune bool, dry bool) error {
	colors.PrimaryPrint("Forgetting for location \"%s\"", l.name)

	path, err := l.getPath()
	if err != nil {
		return err
	}

	for _, to := range l.To {
		backend, _ := GetBackend(to)
		colors.Secondary.Printf("For backend \"%s\"\n", backend.name)
		env, err := backend.getEnv()
		if err != nil {
			return nil
		}
		options := ExecuteOptions{
			Envs: env,
		}
		lFlags := getOptions(l.Options, "forget")
		bFlags := getOptions(backend.Options, "forget")
		cmd := []string{"forget", "--path", path}
		if prune {
			cmd = append(cmd, "--prune")
		}
		if dry {
			cmd = append(cmd, "--dry-run")
		}
		cmd = append(cmd, lFlags...)
		cmd = append(cmd, bFlags...)
		out, err := ExecuteResticCommand(options, cmd...)
		if VERBOSE {
			colors.Faint.Println(out)
		}
		if err != nil {
			return err
		}
	}
	colors.Success.Println("Done")
	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
	}
	colors.PrimaryPrint("Restoring location \"%s\"", l.name)

	backend, _ := GetBackend(from)
	path, err := l.getPath()
	if err != nil {
		return nil
	}
	colors.Secondary.Println("Restoring lastest snapshot")
	colors.Body.Printf("%s → %s.\n", from, path)
	switch l.getType() {
	case TypeLocal:
		// 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
				}
			}
		}
		err = backend.Exec([]string{"restore", "--target", to, "--path", path, "latest"})
	case TypeVolume:
		_, err = backend.ExecDocker(l, []string{"restore", "--target", ".", "--path", path, "latest"})
	}
	if err != nil {
		return err
	}
	colors.Success.Println("Done")
	return nil
}

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

	schedule, err := cron.ParseStandard(l.Cron)
	if err != nil {
		return err
	}
	last := time.Unix(lock.GetCron(l.name), 0)
	next := schedule.Next(last)
	now := time.Now()
	if now.After(next) {
		lock.SetCron(l.name, now.Unix())
		l.Backup(true)
	} else {
		if !CRON_LEAN {
			colors.Body.Printf("Skipping \"%s\", not due yet.\n", l.name)
		}
	}
	return nil
}