package management

import (
	"encoding/json"
	"errors"
	"io/ioutil"
	"log"
	"os"

	"time"

	"domains"

	"github.com/asaskevich/govalidator"
)

var Settings T_Management

type T_Management struct {
	Users   []T_User           `json:"Users"`
	Domains []domains.T_Domain `json:"Names"`
	Debug   bool               `json:"Debug"`
}

type T_User struct {
	Email       string `json:"Email"`
	Password    string `json:"Password"`
	Cookie      string `json:"Cookie"`
	CreatedDate string `json:"CreatedDate"`
}

func (T_Management) SaveConfig() error {
	configFile, err := os.OpenFile("config.json", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0755)

	if err == nil {
		configByte, err := json.MarshalIndent(Settings, "", " ")

		if err != nil {
			log.Fatal("management.SaveConfig: could not Marshall Settings: ", err)
			return errors.New("management.SaveConfig: could not Marshall Settings: " + err.Error())
		}
		_, err = configFile.Write(configByte)
		if err != nil {
			log.Fatal("management.SaveConfig: could not Write Settings: ", err)
			return errors.New("management.SaveConfig: could not Write Settings: " + err.Error())
		}
	} else {
		log.Fatal("management.SaveConfig: could not create new config.json file: ", err)
		return errors.New("management.SaveConfig: could not create new config.json file: " + err.Error())
	}

	defer configFile.Close()

	return nil
}

func (T_Management) LoadConfig() {

}

func (T_Management) ReloadConfig() {

}

func (T_Management) Initialize() {
	configExists, err := os.Open("config.json")

	if err != nil {
		log.Println("management.initialize: new deployment: building config")
		Settings.DefaultSuperAdmin()

		configNew, err := os.OpenFile("config.json", os.O_CREATE|os.O_WRONLY, 0644)
		if err == nil {
			configByte, err := json.MarshalIndent(Settings, "", " ")
			if err != nil {
				log.Fatal("management.initialize: could not Marshall Settings: ", err)
			}
			configNew.Write(configByte)
		} else {
			log.Fatal("management.initialize: could not create new config.json file: ", err)
		}

		defer configNew.Close()
	} else {
		configByte, err := ioutil.ReadAll(configExists)
		if err != nil {
			log.Fatal("management.initialize: could not read config: ", err)
		}

		json.Unmarshal(configByte, &Settings)

		defer configExists.Close()
	}
}

// Needs to be checked if a user already exist
func (T_Management) AddUserByTUser(user T_User) error {
	if !govalidator.IsEmail(user.Email) {
		return errors.New("email is not an email")
	}
	if user.Email == "" {
		return errors.New("email cannot be empty")
	}
	if user.Password == "" {
		return errors.New("password cannot be empty")
	}
	currentTime := time.Now()
	user.CreatedDate = currentTime.Format("2006-January-02")

	Settings.Users = append(Settings.Users, user)

	return nil
}

func (T_Management) AddUserByParams(email string, passwd string) error {
	var temp T_User
	temp.Email = email
	temp.Password = passwd
	err := Settings.AddUserByTUser(temp)

	return err
}

func (T_Management) RemoveUserByEmail(email string) error {
	found := false
	for index, u := range Settings.Users {
		if u.Email == email {
			temp := append(Settings.Users[:index], Settings.Users[index+1])
			Settings.Users = temp
			found = true
			return nil
		}
	}
	if !found {
		return errors.New("did not find a user:" + email)
	}
	return nil
}

func (T_Management) CheckPassword(email string, passwd string) (bool, error) {
	found := false
	for _, u := range Settings.Users {
		if u.Email == email && u.Password == passwd {
			return true, nil
		}
	}
	if !found {
		return false, errors.New("no combination with:" + email + " :" + passwd)
	}
	return false, nil
}

func (T_Management) SaveCookie(email string, cookie string) error {
	for index, u := range Settings.Users {
		if u.Email == email {
			Settings.Users[index].Cookie = cookie
			return nil
		}
	}
	return nil
}

func (T_Management) OnboardDomain(name string, realServer string, realPort string) (bool, error) {
	if !govalidator.IsDNSName(name) {
		return false, errors.New("given name is not a DNS name")
	}
	if !govalidator.IsDNSName(realServer) && !govalidator.IsIP(realServer) {
		return false, errors.New("given realServer is not a valid DNS name or IP Address")
	}
	if !govalidator.IsPort(realPort) {
		return false, errors.New("given realPort is not a valid Port number")
	}

	Settings.AddDomainByParams(name, realServer, realPort)

	return true, nil
}

func (T_Management) UserFindByEmail(email string) (T_User, error) {
	found := false
	var temp T_User
	for _, u := range Settings.Users {
		if u.Email == email {
			return u, nil
		}
	}
	if !found {
		return temp, errors.New("no combination with:" + email)
	}
	return temp, nil
}

func (T_Management) AllUsers() []T_User {
	return Settings.Users
}

func (T_Management) DefaultSuperAdmin() {
	Settings.Debug = false
	Settings.AddUserByParams("defadm@daydev.org", "siconmas")
}

func (T_Management) ToString() string {
	managementString, err := json.Marshal(Settings)

	if err != nil {
		log.Println("management.ToString: " + err.Error())
	}

	return string(managementString)
}

//--- Domains
func (T_Management) AddDomainByDomain(domain domains.T_Domain) {
	domain.Status = domains.Onboarding
	Settings.Domains = append(Settings.Domains, domain)
}

func (T_Management) AddDomainByParams(name string, realServer string, realPort string) {
	var temp domains.T_Domain
	temp.DomainName = name
	temp.RealServer = realServer
	temp.RealPort = realPort
	temp.Status = domains.Onboarding

	Settings.AddDomainByDomain(temp)
}

func (T_Management) RemoveDomain(name string) {
	for index, v := range Settings.Domains {
		if v.DomainName == name {
			temp := append(Settings.Domains[:index], Settings.Domains[index+1])
			Settings.Domains = temp
		}
	}
}

func (T_Management) FindDomainByName(name string) domains.T_Domain {
	var temp domains.T_Domain
	for index, v := range Settings.Domains {
		if v.DomainName == name {
			temp = Settings.Domains[index]
		}
	}
	return temp
}

//--- END Domains