/*
 * Copyright (C) 2017-2018 "IoT.bzh"
 * Author Clément Bénier <clement.benier@iot.bzh>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package xdsservertest

import (
	"log"
	"net"
	"os"
	"regexp"
	"strings"
	"testing"
	"time"

	common "gerrit.automotivelinux.org/gerrit/src/xds/xds-common.git/golib"
	"gerrit.automotivelinux.org/gerrit/src/xds/xds-server/lib/xsapiv1"
	"github.com/stretchr/testify/assert"
)

//global client
var HTTPCli *common.HTTPClient
var logDir string

func initEnv() {
	rootTestLog := "/tmp/xds-server-test"
	if err := os.Setenv(envRootCfgDir, rootTestLog); err != nil {
		log.Fatal(err)
	}
	os.RemoveAll(rootTestLog)
	os.MkdirAll(rootTestLog, 0755)
	logDir = rootTestLog + "/logs/"
	os.MkdirAll(logDir, 0755)
}

func launchXdsServer(proc **os.Process) *os.File {
	logFile := logDir + logFileXdsServer
	file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		log.Fatal(err)
	}
	tmpProc, err := os.StartProcess(argsProcess[0], argsProcess, &os.ProcAttr{
		Files: []*os.File{os.Stdin, file, file},
	})
	if err != nil {
		log.Fatal(err)
	}
	*proc = tmpProc
	return file
}

func getHTTPClient(lvl int) (*common.HTTPClient, *os.File) {
	logFile := logDir + logFileClient
	file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		log.Fatal(err)
	}
	conf := common.HTTPClientConfig{
		URLPrefix:           "/api/v1",
		HeaderClientKeyName: "Xds-Test-Sid",
		CsrfDisable:         true,
		LogOut:              file,
		LogPrefix:           "XDSSERVERTEST: ",
		LogLevel:            lvl,
	}
	cli, err := common.HTTPNewClient(prefixURL, conf)
	if err != nil {
		log.Print(err)
	}
	return cli, file
}

func TestMain(m *testing.M) {
	initEnv()

	var proc *os.Process
	fileXdsServer := launchXdsServer(&proc)
	go func(p *os.Process) {
		if status, err := p.Wait(); err != nil {
			log.Fatalf("status=%v\n err=%v\n", status, err)
		}
	}(proc)
	time.Sleep(1 * time.Second)

	lvl := common.HTTPLogLevelDebug
	var fileHTTPClient *os.File
	HTTPCli, fileHTTPClient = getHTTPClient(lvl)

	if HTTPCli == nil {
		log.Fatal("HTTPCLi is nil")
	}
	res := m.Run()
	proc.Kill()
	fileXdsServer.Close()
	fileHTTPClient.Close()
	os.Exit(res)
}

func init() {
}

func CheckIP(ipconfig string) bool {
	ifaces, _ := net.Interfaces()
	for _, i := range ifaces {
		addrs, _ := i.Addrs()
		for _, addr := range addrs {
			if strings.HasPrefix(addr.String(), ipconfig) {
				return true
			}
		}
	}
	return false
}

func TestVersion(t *testing.T) {
	var datVersion map[string]interface{}
	assert.Nil(t, HTTPCli.Get("/version", &datVersion))
	t.Log(datVersion)

	ver, present := datVersion["version"]
	assert.True(t, present)
	t.Logf("version is %s", ver.(string))
	re := regexp.MustCompile("^v*[0-9]+.[0-9]+.[0-9]+$")
	assert.True(t, re.MatchString(ver.(string)))
}

func TestConfig(t *testing.T) {
	var datConfig map[string]interface{}
	assert.Nil(t, HTTPCli.Get("/config", &datConfig))

	builder, present := datConfig["builder"].(map[string]interface{})
	assert.True(t, present)
	ip, present := builder["ip"]
	assert.True(t, present)
	assert.True(t, CheckIP(ip.(string)))
}
func TestFolders(t *testing.T) {
	var datFolder []interface{}
	assert.Nil(t, HTTPCli.Get("/folders", &datFolder))
	t.Log(datFolder)
	assert.Equal(t, len(datFolder), 0)

	fPrj := xsapiv1.FolderConfig{
		Label:      "testproject",
		ClientPath: logDir + "testproject",
		Type:       xsapiv1.TypePathMap,
		ClientData: "clientdatatest",
		DataPathMap: xsapiv1.PathMapConfig{
			ServerPath: logDir + "testserverpath",
		},
	}
	var cfg xsapiv1.FolderConfig
	assert.Nil(t, HTTPCli.Post("/folders", fPrj, &cfg))
	assert.NotNil(t, cfg)
	t.Log(cfg)

	isCfgPrjMatch := func(fPrj xsapiv1.FolderConfig, cfg xsapiv1.FolderConfig) {
		re := regexp.MustCompile("^[0-9a-z]+-[0-9a-z]+-[0-9a-z]+-[0-9a-z]+-[0-9a-z]+$")
		assert.True(t, re.MatchString(cfg.ID)) //ID
		assert.Equal(t, cfg.Label, fPrj.Label) //Label
		assert.Equal(t, cfg.ClientPath, fPrj.ClientPath)
		assert.Equal(t, cfg.Type, fPrj.Type)
		assert.Equal(t, cfg.Status, "Enable")
		assert.Equal(t, cfg.IsInSync, true)
		assert.Equal(t, len(cfg.DefaultSdk), 0)
		assert.Equal(t, fPrj.ClientData, cfg.ClientData)
		assert.Equal(t, fPrj.DataPathMap.ServerPath, cfg.DataPathMap.ServerPath)
	}
	isCfgPrjMatch(fPrj, cfg)
	var cfg2 xsapiv1.FolderConfig
	assert.Nil(t, HTTPCli.Get("/folders/"+cfg.ID, &cfg2))
	t.Log(cfg2)
	isCfgPrjMatch(fPrj, cfg2)

	//call with the same uid create error
	assert.NotNil(t, HTTPCli.Post("/folders", cfg, &cfg))

	//assert.Equal(t, cfg.DefaultSdk, "true")
	//call with the same uid
	//serverpath nil
	//serverpath already exists
}

//func TestRegister(t *testing.T) {
//	var client := common.HTTPClient
//	client.Get("/folders", folders)
//}