package samba

import (
	"encoding/json"
	"net/http"
	"path/filepath"
	"strings"

	"imuslab.com/arozos/mod/utils"
)

// Get current samba service status
func (s *ShareManager) SmbdStates(w http.ResponseWriter, r *http.Request) {
	set, err := utils.PostPara(r, "set")
	if err != nil {
		//return the current smbd states
		smbdRunning, err := IsSmbdRunning()
		if err != nil {
			utils.SendErrorResponse(w, err.Error())
			return
		}

		js, _ := json.Marshal(smbdRunning)
		utils.SendJSONResponse(w, string(js))
		return
	} else if set == "enable" {
		//Set smbd to enable
		err = SetSmbdEnableState(true)
		if err != nil {
			utils.SendErrorResponse(w, err.Error())
			return
		}

		utils.SendOK(w)
		return
	} else if set == "disable" {
		//Set smbd to disable
		err = SetSmbdEnableState(false)
		if err != nil {
			utils.SendErrorResponse(w, err.Error())
			return
		}

		utils.SendOK(w)
		return
	}

	utils.SendErrorResponse(w, "not support set state: "+set+". Only support enable /disable")
}

// List all the samba shares
func (s *ShareManager) ListSambaShares(w http.ResponseWriter, r *http.Request) {
	shares, err := s.ReadSambaShares()
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	//Remove those shares that is reserved by systems
	shares = s.FilterSystemCreatedShares(shares)

	js, _ := json.Marshal(shares)
	utils.SendJSONResponse(w, string(js))
}

// Add a samba share
func (s *ShareManager) AddSambaShare(w http.ResponseWriter, r *http.Request) {
	shareName, err := utils.PostPara(r, "name")
	if err != nil {
		utils.SendErrorResponse(w, "share name not given")
		return
	}

	shareName = strings.TrimSpace(shareName)

	//Check if this share name already been used
	shareNameExists, err := s.ShareNameExists(shareName)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}
	if shareNameExists {
		utils.SendErrorResponse(w, "share with identical name already exists")
		return
	}

	sharePath, err := utils.PostPara(r, "path")
	if err != nil {
		utils.SendErrorResponse(w, "share path not given")
		return
	}

	//Parse the path to absolute path
	absoluteSharePath, err := filepath.Abs(sharePath)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	//Check if path exists
	if !utils.FileExists(absoluteSharePath) {
		utils.SendErrorResponse(w, "target path not exists")
		return
	}

	//Check if target path is a folder
	if !utils.IsDir(absoluteSharePath) {
		utils.SendErrorResponse(w, "target path is not a directory")
		return
	}

	//Check if it is a reserved / protected path
	if isPathInsideImportantFolders(absoluteSharePath) {
		utils.SendErrorResponse(w, "system reserved path cannot be shared")
		return
	}

	validUsersJSON, err := utils.PostPara(r, "users")
	if err != nil {
		utils.SendErrorResponse(w, "no valid user givens")
		return
	}

	//Parse valid users into string slice
	validUsers := []string{}
	err = json.Unmarshal([]byte(validUsersJSON), &validUsers)
	if err != nil {
		utils.SendErrorResponse(w, "unable to parse JSON for valid users")
		return
	}

	//Check if all the users exists in the host OS
	for _, validUser := range validUsers {
		thisUnixUserExists, err := s.SambaUserExists(validUser)
		if err != nil {
			utils.SendErrorResponse(w, err.Error())
			return
		}

		if !thisUnixUserExists {
			//This user not exists
			utils.SendErrorResponse(w, validUser+" is not a valid unix user")
			return
		}
	}

	readOnly, err := utils.PostBool(r, "readonly")
	if err != nil {
		readOnly = false
	}

	browseable, err := utils.PostBool(r, "browseable")
	if err != nil {
		browseable = true
	}

	allowGuest, err := utils.PostBool(r, "guestok")
	if err != nil {
		allowGuest = false
	}

	shareToCreate := ShareConfig{
		Name:       shareName,
		Path:       absoluteSharePath,
		ValidUsers: validUsers,
		ReadOnly:   readOnly,
		Browseable: browseable,
		GuestOk:    allowGuest,
	}

	//Add the new share to smb.conf
	err = s.CreateNewSambaShare(&shareToCreate)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	//Restart smbd
	err = restartSmbd()
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	utils.SendOK(w)
}

// Remove a samba share by name
func (s *ShareManager) DelSambaShare(w http.ResponseWriter, r *http.Request) {
	shareName, err := utils.PostPara(r, "name")
	if err != nil {
		utils.SendErrorResponse(w, "share name not given")
		return
	}

	//Check if share exists
	shareExists, err := s.ShareExists(shareName)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	if !shareExists {
		utils.SendErrorResponse(w, "share to be remove not exists")
		return
	}

	//Remove the share from config file
	err = s.RemoveSambaShareConfig(shareName)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	//Restart smbd
	err = restartSmbd()
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	utils.SendOK(w)
}

// Add a new samba user
func (s *ShareManager) NewSambaUser(w http.ResponseWriter, r *http.Request) {
	//TODO: Replace the GetPara to Post
	username, err := utils.GetPara(r, "username")
	if err != nil {
		utils.SendErrorResponse(w, "username not given")
		return
	}

	password, err := utils.GetPara(r, "password")
	if err != nil {
		utils.SendErrorResponse(w, "password not set")
		return
	}

	err = s.AddSambaUser(username, password)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	utils.SendOK(w)
}

// Remove a samba user
func (s *ShareManager) DelSambaUser(w http.ResponseWriter, r *http.Request) {
	username, err := utils.GetPara(r, "username")
	if err != nil {
		utils.SendErrorResponse(w, "username not given")
		return
	}

	//Remove the samba user
	err = s.RemoveSmbUser(username)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	utils.SendOK(w)
}

// List all samba users info
func (s *ShareManager) ListSambaUsers(w http.ResponseWriter, r *http.Request) {
	userInfo, err := s.ListSambaUsersInfo()
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	js, _ := json.Marshal(userInfo)
	utils.SendJSONResponse(w, string(js))
}