package helm

import (
    "fmt"
    "strconv"
    "os"
    "strings"
    "errors"
    "path/filepath"
    "encoding/json"
    log "oc-deploy/log_wrapper"
)

type HelmChart struct {
    Bin string
    Name string
    Chart string
    Version string
    Url string

    Workspace string
    Opts string
    Values map[string]string
    FileValues []string
}

type installInfoOutput struct {
    Description string  `json:"description"`
    Notes string  `json:"notes"`
    Status string  `json:"status"`
}

type installOutput struct {
    Info installInfoOutput  `json:"info"`
}

func (this HelmCommand) ChartInstall(data HelmChart) (string, error) {
    bin := this.Bin

    existe, err := this.chartExists(data)
    if err != nil {
        return "", err
    }
    
    if existe {
        return "Existe déjà", nil
    }

    ficChart := data.Chart
    // Recherche locale
    if _, err := os.Stat(ficChart); err != nil {
    } else {
        // Recherche voa le Workspace
        ficChart := filepath.Join(data.Workspace, data.Chart)
        if _, err := os.Stat(ficChart); err == nil {
        } else {
            if data.Url != "" {
                fmt.Println("============ 52 Télechargement", data.Url)
            }
        }
    }

    msg := fmt.Sprintf("%s install %s %s %s --output json", bin, data.Name, ficChart, data.Opts)

    if data.Version != "" {
        msg = fmt.Sprintf("%s --version %s", msg, data.Version)
    }

    for key, value := range data.Values {
        msg = fmt.Sprintf("%s --set %s=%s", msg, key, value)
    }

    ficoverwrite := filepath.Join(data.Workspace, fmt.Sprintf("value-%s.yml", data.Name))
    if _, err := os.Stat(ficoverwrite); err != nil {
        log.Log().Warn().Msg(ficoverwrite)
    } else {
        msg = fmt.Sprintf("%s --values %s", msg, ficoverwrite)
    }

    for _, valuefilename := range data.FileValues {
        fic := filepath.Join(data.Workspace, valuefilename)
        if _, err := os.Stat(fic); err != nil {
            log.Log().Warn().Msg(fic)
        } else {
            msg = fmt.Sprintf("%s --values %s", msg, fic)
        }
    }

    msg = strings.Replace(msg, "  ", " ", -1)

    log.Log().Debug().Msg(msg)

    cmd_args := strings.Split(msg, " ")
	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
    stdout, err := cmd.CombinedOutput()

    if err != nil {
        res := string(stdout)
        res = strings.TrimSuffix(res, "\n")
        return "", errors.New(res)
    }

    var objmap installOutput

    i := strings.Index(string(stdout), "{")
    stdout2 := string(stdout)[i:]

    err = json.Unmarshal([]byte(stdout2), &objmap)
    if err != nil {
        return "", err
    }

    res := objmap.Info.Status

    return res, nil
}

func (this HelmCommand) ChartUninstall(data HelmChart) (string, error) {
    bin := this.Bin

    log.Log().Info().Msg("  >> Chart : " + data.Name)

    existe, err := this.chartExists(data)
    if err != nil {
        return "", err
    }
    if ! existe {
        return "Non présent", nil
    }

    msg := fmt.Sprintf("%s uninstall %s", bin, data.Name)
    log.Log().Debug().Msg(msg)

    cmd_args := strings.Split(msg, " ")
	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
    stdout, err := cmd.CombinedOutput()

    res := string(stdout)
    res = strings.TrimSuffix(res, "\n")

    log.Log().Debug().Msg(res)

    return res, err
}

// ../bin/helm list --filter phpmyadminm --short
func (this HelmCommand) chartExists(data HelmChart) (bool, error) {

    bin := this.Bin

    msg := fmt.Sprintf("%s list --filter %s --no-headers", bin, data.Name)
    log.Log().Debug().Msg(msg)

    cmd_args := strings.Split(msg, " ")
	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
    stdout, err := cmd.CombinedOutput()
    if err != nil {
        log.Log().Debug().Msg(string(stdout))
        return false, errors.New(string(stdout))
    }

    res := string(stdout)
    res = strings.TrimSuffix(res, "\n")

    log.Log().Debug().Msg(string(stdout))
    log.Log().Debug().Msg(strconv.FormatBool(res != ""))

    return res != "", nil
}