package scripts

import (
	"encoding/json"
	"log"
)

type (
	// Credential is currently a ssh key, but may be a password hash in the future
	Credential struct {
		ID    int    `json:"id,omitempty"`
		Type  string `json:"type,omitempty"`
		Name  string `json:"name"`
		Value string `json:"value"`
	}

	// UserCredentialStates serves to inform the backend about the per credential states
	// after the script run
	// This maps a credential type like "ssh_key" to a map of the states of credentials of this
	// type.
	UserCredentialStates map[string]map[string]State

	// UserCredentials maps a credential type to the credentials of this type
	UserCredentials map[string][]Credential

	// UserInfo info about the user
	UserInfo map[string]interface{}

	// User contains information concerning the user of a deployment
	User struct {
		UserInfo    UserInfo        `json:"userinfo"`
		Credentials UserCredentials `json:"credentials"`
	}

	// Input of the deployment script
	Input struct {
		// StateTarget is the state which is to be reached by this deployment task
		// StateTarget is either Deployed or NotDeployed
		StateTarget State `json:"state_target"`

		// User describes the user of this deployment task
		User User `json:"user"`

		// Answers is an answered questionnaire
		// Maps a question name to the answer of the user
		// The keys (question names) *must* be identical to those of the Output.Questionnaire
		// containing the questions
		Answers map[string]string `json:"answers,omitempty"`
	}

	// Output of the deployment script
	Output struct {
		// State describes the state of the deployment, after the script execution.
		// When State == Questionnaire then Output.Questionnaire *must* be set.
		// When State == Deployed then Output.Credentials *can* be set.
		State State `json:"state"`

		// Msg is a message for the user.
		Msg string `json:"message"`

		// Questionnaire requested by the script
		// This field is Ignored when Output.State is not Questionnaire.
		// Questionnaire maps a question name to a question.
		Questionnaire map[string]string `json:"questionnaire,omitempty"`

		// Credentials are additionnal credentials for the user.
		// Examples are additional passwords.
		// This field is ignored by the client when Output.State is not Deployed.
		// Credentials maps a credential name to a credential value.
		Credentials map[string]string `json:"credentials,omitempty"`

		// UserCredentialStates are the State s of the credentials found in Input.User.Credentials.
		// This field is not mandatory. The client will assume that all credentials have the State
		// Output.State if this field is not given.
		UserCredentialStates UserCredentialStates `json:"user_credential_states,omitempty"`
	}

	// State is a string enum
	// The enum values for State are listed below
	State string
)

const (
	// Deployed value for State
	Deployed State = "deployed"

	// NotDeployed value for State
	NotDeployed State = "not_deployed"

	// Rejected value for State
	// the user can never be deployed
	Rejected State = "rejected"

	// Failed value for State
	// the deployment can be retried
	Failed State = "failed"

	// Questionnaire value for State
	// the user has to fill the questionnaire
	// with the questionnaire data the deployment can be retried
	Questionnaire State = "questionnaire"
)

func (u User) String() string {
	if email, ok := u.UserInfo["email"]; ok {
		return email.(string)
	}
	if name, ok := u.UserInfo["name"]; ok {
		return name.(string)
	}
	return ""
}

func (i Input) String() string {
	iBytes, err := i.Marshal()
	if err != nil {
		log.Fatal(err)
	}
	return string(iBytes)
}

func (o Output) String() string {
	oBytes, err := o.Marshal()
	if err != nil {
		log.Fatal(err)
	}
	return string(oBytes)
}

// Marshal encodes an Input as json
func (i Input) Marshal() (iBytes []byte, err error) {
	iBytes, err = json.MarshalIndent(i, "", "    ")
	return
}

// Marshal encodes an Output as json
func (o Output) Marshal() (oBytes []byte, err error) {
	oBytes, err = json.MarshalIndent(o, "", "    ")
	return
}

// UnmarshalInput decodes a json encoded input
func UnmarshalInput(inputBytes []byte) (i Input, err error) {
	err = json.Unmarshal(inputBytes, &i)
	return
}

// UnmarshalOutput decodes a json encoded output
func UnmarshalOutput(inputBytes []byte) (i Output, err error) {
	err = json.Unmarshal(inputBytes, &i)
	return
}