package templater

import (
	"encoding/json"
	"fmt"
	"path/filepath"

	"github.com/mitchellh/mapstructure"
)

type Service struct {
	ConfigFiles []ConfigFile             `json:"ConfigFiles"`
	Vars        map[string]interface{}   `json:"Vars"`
	Daemons     map[string]SystemService `json:"Daemons"`
	Users       map[string]SystemUser    `json:"Users"`
	Repos       map[string]interface{}   `json:"Repositories"`
	Packages    map[string]SystemPackage `json:"Packages"`
}

func (s *Service) manageRepo(repo interface{}) error {
	fmt.Printf("%v\n", repo)
	if repo["type"] == "helm" {
		var rp HelmRepository
		mapstructure.Decode(repo, rp)
	}

	return nil
}

func (s *Service) Manage(templateDir string) error {

	for _, repo := range s.Repos {
		if err := s.manageRepo(repo); err != nil {
			return err
		}

	}

	// Manage system packages
	for _, pack := range s.Packages {
		err := pack.Manage()
		if err != nil {
			return err
		}
	}

	err := processConfigFiles(s.ConfigFiles, s.Vars, templateDir)
	if err != nil {
		return fmt.Errorf("ProcessingTemplatesFailed with error: %v", err)
	}

	for _, daemon := range s.Daemons {
		err = daemon.Manage()
		if err != nil {
			return fmt.Errorf("Error managing service daemons: %v", err)
		}
	}
	return nil
}

func processConfigFiles(tpls []ConfigFile, variables map[string]interface{}, templateDir string) error {
	values, err := json.Marshal(variables)
	if err != nil {
		return fmt.Errorf("Error unmarshaling values on template process; %v", err)
	}

	for _, tpl := range tpls {
		fileExt := filepath.Ext(tpl.Source)
		if fileExt == ".hcl" {
			tpl.TemplateType = "hcl"
		} else if fileExt == ".tpl" {
			tpl.TemplateType = "go"
		} else {
			return fmt.Errorf("Unsupported file extention %s, templates extensions have to be '.hcl' or '.tpl'", fileExt)
		}
		if err := tpl.Generate("/tmp/test", templateDir, values); err != nil {
			return fmt.Errorf("Template %s generation failed with error %v", tpl.Source, err)
		}

	}
	return nil
}