package FlyWebRoots

import (
	"archive/zip"
	"bytes"
	"encoding/base64"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"path"
	"path/filepath"
	"strings"

	"gitee.com/flyiot/flylibs/FlyAPIs"
	"gitee.com/flyiot/flylibs/FlyUtils"
)

type FlyWebRoot struct {
	Enable bool
	Map    map[string][]byte

	Settings *FlyWebRootSettings
}

func NewFlyWebRoot() *FlyWebRoot {
	s := FlyWebRoot{}
	s.Map = make(map[string][]byte)
	s.Settings = NewFlyWebRootSettings()

	return &s
}

func (s *FlyWebRoot) Start(server FlyAPIs.FlyApiServerBasicInterface, settings *FlyWebRootSettings) (err error) {
	defer func() {
		if err2 := recover(); err2 != nil {
			err = log.Error(err2)
		}
	}()

	s.Settings = settings

	if s.Settings.Path == "" {
		return log.Error("FlyWebRoot Settings Path Empty")
	}
	server.HandleFunc(s.Settings.Path, s.handle)
	log.Info("WebRoot", "ServeAt", s.Settings.Path)
	return s.Reload()
}

func (s *FlyWebRoot) Stop() {
	s.Map = make(map[string][]byte)
}

func (s *FlyWebRoot) Reload() error {
	s.Map = make(map[string][]byte)
	return s.AutoLoad(s.Settings.Dir)
}

func (s *FlyWebRoot) AutoLoad(name string) error {
	name = FlyUtils.Trim(name)
	log.Info("WebRoot", "autoload", name)

	if name == "" {
		//如果名称为空，加载默认
		return s.LoadDefault()
	}

	if fileInfo, err := os.Stat(name); os.IsNotExist(err) {
		//如果不存在，加载默认
		return s.LoadDefault()
	} else if !fileInfo.IsDir() {
		//如果不是目录
		log.Info("WebRoot", "load", "file")

		str := FlyUtils.ReadFile2str(name)
		return s.LoadStr(str)
	} else {
		//如果是目录
		log.Info("WebRoot", "load", "dir")
		if !strings.HasSuffix(name, "/") {
			name = name + "/"
		}
		str, err := s.BuildWebRoot(name)
		if err != nil {
			return err
		}
		return s.LoadStr(str)
	}
}

// 加载默认数据
func (s *FlyWebRoot) LoadDefault() error {
	log.Info("WebRoot", "load", "default")
	return s.LoadStr(DefaultData)
}

// 加载字符串数据
func (s *FlyWebRoot) LoadStr(data string) error {
	var err error
	s.Map, err = s.DataStr2Map(data)
	log.Info("WebRoot", "load", "end")
	return log.Error(err)
}

// 将网站数据解析到map中
func (s *FlyWebRoot) DataStr2Map(data string) (map[string][]byte, error) {

	maps := make(map[string][]byte)

	decodeBytes, err := base64.StdEncoding.DecodeString(data)
	if err != nil {
		return maps, err
	}
	// decoder := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
	// n := base64.StdEncoding.DecodedLen(len(data))

	file, err1 := ioutil.TempFile("", "tmpdata")
	if err1 != nil {
		return maps, err1
	}
	defer os.Remove(file.Name())

	ioutil.WriteFile(file.Name(), []byte(decodeBytes), 0777)

	cf, err2 := zip.OpenReader(file.Name())
	if err2 != nil {
		return maps, err2
	}

	for _, file := range cf.File {

		if f, err := file.Open(); err == nil {
			defer f.Close()
			if buf, err := ioutil.ReadAll(f); err == nil {
				maps[file.Name] = buf
			} else {
				return maps, err
			}

		}

	}

	return maps, nil
}

// 将一个目录打包成字符串
func (s *FlyWebRoot) BuildWebRoot(dir string) (string, error) {

	srcFile := dir

	buf := bytes.NewBuffer(make([]byte, 0))

	archive := zip.NewWriter(buf)
	defer archive.Close()

	// zipFolder(srcFile, archive)

	filepath.Walk(srcFile, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		header, err := zip.FileInfoHeader(info)
		if err != nil {
			return err
		}

		header.Name = strings.TrimPrefix(path, filepath.Dir(srcFile)+"/")
		// if header.Name == "." || header.Name == ".." || header.Name == "" {
		// 	return nil
		// }
		// header.Name = path
		if info.IsDir() {
			header.Name += "/"
		} else {
			header.Method = zip.Deflate
		}

		writer, err := archive.CreateHeader(header)
		// writer, err := archive.Create(path)
		if err != nil {
			return err
		}

		if !info.IsDir() {
			file, err := os.Open(path)
			if err != nil {
				return err
			}
			defer file.Close()
			_, err = io.Copy(writer, file)

		}
		return err
	})
	archive.Close()

	// 完成zip打包，进行编码，写入文件
	encodeString := base64.StdEncoding.EncodeToString(buf.Bytes())

	return encodeString, nil
}

func (s *FlyWebRoot) handle(w http.ResponseWriter, r *http.Request) {

	url := r.URL.Path

	// fmt.Println(url)

	if strings.HasSuffix(url, "/") {
		url = url + s.Settings.Index
	}
	url = strings.TrimPrefix(url, "/")

	if data, ok := s.Map[url]; ok {
		fileExt := path.Ext(url)
		// fmt.Println(fileExt)
		switch fileExt {
		case ".js":
			w.Header().Set("content-type", "application/javascript")
		case ".css":
			w.Header().Set("content-type", "text/css")
		case ".jpg":
			w.Header().Set("content-type", "image/jpeg")
		case ".png":
			w.Header().Set("content-type", "image/png")
		case ".woff":
			w.Header().Set("content-type", "font/woff")
		case ".ttf":
			w.Header().Set("content-type", "font/ttf")
		case ".json":
			w.Header().Set("content-type", "application/json")
		default:

		}
		w.Write(data)
		return
	}
	w.Write([]byte("not found"))

}