package client

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
	"path/filepath"
	"time"
	"encoding/json"
	"compress/gzip"
	"io/ioutil"
	"strings"
	"git.qianqiusoft.com/qianqiusoft/light-apiengine/utils"
)

type EngineClient struct {
	ProjectName string
}

type ResponeResult struct {
	Code   int32 `json:"code"`
	//描述
	Msg   string `json:"msg"`
	//数据
	Data   []GenerateResult `json:"data"`
}
type GenerateResult struct {
	Name string `json:"name"`
	Content []byte `json:"content"`
	Type string `json:"type"`
}

func NewEngineClient(project_name string) *EngineClient {
	return &EngineClient{project_name}
}

func (c * EngineClient)InitDefalutFile(project_name string)  {
	c.ProjectName = project_name
	os.MkdirAll("controllers", os.ModePerm)
	os.MkdirAll("models", os.ModePerm)
	os.MkdirAll("routers", os.ModePerm)
	os.MkdirAll("conf", os.ModePerm)
	os.MkdirAll("sqlconfig", os.ModePerm)

	_,err:=os.Stat(project_name+".xml")
	if os.IsNotExist(err){
		xml:=strings.Replace(DefaultProjectXML, "{project_name}", project_name,-1)
		ioutil.WriteFile(project_name+".xml",[]byte(xml), os.ModePerm)
	}

	_,err =os.Stat(project_name+".xsd")
	if os.IsNotExist(err) {
		ioutil.WriteFile(project_name+".xsd", []byte(XSD), os.ModePerm)
	}

	_,err =os.Stat("Dockerfile")
	if os.IsNotExist(err) {
		xml:=strings.Replace(DockerFile, "{project_name}", project_name,-1)
		ioutil.WriteFile("Dockerfile", []byte(xml), os.ModePerm)
	}
	_,err =os.Stat("build_docker.sh")
	if os.IsNotExist(err) {
		xml:=strings.Replace(BuildSH, "{project_name}", project_name,-1)
		ioutil.WriteFile("build_docker.sh", []byte(xml), os.ModePerm)
	}
}

func (c * EngineClient)GenerateCurrentProject() {
	path,_:=utils.GetCurrentPath()
	c.InitDefalutFile(c.ProjectName)
	c.Generate(path+c.ProjectName+".xml")
}

func (c * EngineClient)Generate(xmlfile string)  {
	time.Sleep(2000)
	var result ResponeResult
	bs := DoRequest(xmlfile)
	if bs !=nil {
		err:=json.Unmarshal(bs.Bytes(), &result)
		if err!=nil{
			fmt.Println(err.Error())
		}
		for i := 0; i < len(result.Data); i++ {
			var b bytes.Buffer
			b.Write(result.Data[i].Content)
			unzip := unzipbytes(&b)
			result.Data[i].Content = unzip.Bytes()
		}
		for i := 0; i < len(result.Data); i++ {
			path:= result.Data[i].Name
			//fmt.Println(path)
			path = path[len(c.ProjectName)+1:]
			fmt.Println(path)
			ft:=result.Data[i].Type
			if result.Data[i].Type == "main" {
			}else if ft == "config"{
				_,err := os.Stat(path)
				if err == nil{
					fmt.Println("配置文件已经存在，忽略...")
				}else {
					ioutil.WriteFile(path, result.Data[i].Content,os.ModePerm)
				}
			}else if ft =="controllers"{
				if strings.Index(path, "_gen.go")>0 {
					ioutil.WriteFile(path, result.Data[i].Content,os.ModePerm)
				}else {
					_, err := os.Stat(path)
					if err==nil{
						ioutil.WriteFile(path+"_new", result.Data[i].Content,os.ModePerm)
					}else if os.IsNotExist(err){
						ioutil.WriteFile(path, result.Data[i].Content,os.ModePerm)
					}
				}
			}else {
				err:=ioutil.WriteFile(path, result.Data[i].Content,os.ModePerm)
				if err !=nil{
					fmt.Println(err.Error())
				}
			}
		}
	}
}


func unzipbytes(bs *bytes.Buffer) bytes.Buffer{
	r, _ := gzip.NewReader(bs)
	defer r.Close()
	var b bytes.Buffer
	b.ReadFrom(r)
	//undatas, _ := ioutil.ReadAll(r)
	//fmt.Println("ungzip size:", len(undatas))
	return b
}

func DoRequest(xmlfile string) *bytes.Buffer{
	server:="http://qianqiusoft.com:6166/api/v1/develop/generate"
	request, err := newfileUploadRequest(server, nil, "xmlfile", xmlfile)
	if err != nil {
		fmt.Println(err)
	}
	client := &http.Client{}
	resp, err := client.Do(request)
	if err != nil {
		fmt.Println(err)
	} else {
		body := &bytes.Buffer{}
		_, err := body.ReadFrom(resp.Body)
		if err != nil {
			fmt.Println(err)
		}
		resp.Body.Close()
		fmt.Println(resp.StatusCode)
		fmt.Println(resp.Header)

		//fmt.Println(body)
		return  body
	}
	return nil
}

func newfileUploadRequest(uri string, params map[string]string, paramName, path string) (*http.Request, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, err := writer.CreateFormFile(paramName, filepath.Base(path))
	if err != nil {
		return nil, err
	}
	_, err = io.Copy(part, file)

	for key, val := range params {
		_ = writer.WriteField(key, val)
	}
	err = writer.Close()
	if err != nil {
		return nil, err
	}

	request, err := http.NewRequest("POST", uri, body)
	request.Header.Add("Content-Type", writer.FormDataContentType())
	return request, err
}