// SiYuan - Build Your Eternal Digital Garden
// Copyright (c) 2020-present, b3log.org
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

package bazaar

import (
	"errors"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"sync"

	"github.com/88250/gulu"
	"github.com/dustin/go-humanize"
	ants "github.com/panjf2000/ants/v2"
	"github.com/siyuan-note/httpclient"
	"github.com/siyuan-note/logging"
	"github.com/siyuan-note/siyuan/kernel/util"
)

type Theme struct {
	Author  string   `json:"author"`
	URL     string   `json:"url"`
	Version string   `json:"version"`
	Modes   []string `json:"modes"`

	Name            string `json:"name"`
	RepoURL         string `json:"repoURL"`
	RepoHash        string `json:"repoHash"`
	PreviewURL      string `json:"previewURL"`
	PreviewURLThumb string `json:"previewURLThumb"`

	README string `json:"readme"`

	Installed  bool   `json:"installed"`
	Outdated   bool   `json:"outdated"`
	Current    bool   `json:"current"`
	Updated    string `json:"updated"`
	Stars      int    `json:"stars"`
	OpenIssues int    `json:"openIssues"`
	Size       int64  `json:"size"`
	HSize      string `json:"hSize"`
	HUpdated   string `json:"hUpdated"`
	Downloads  int    `json:"downloads"`
}

func Themes() (ret []*Theme) {
	ret = []*Theme{}
	result, err := util.GetRhyResult(false)
	if nil != err {
		return
	}

	bazaarIndex := getBazaarIndex()
	bazaarHash := result["bazaar"].(string)
	result = map[string]interface{}{}
	request := httpclient.NewBrowserRequest()
	u := util.BazaarOSSServer + "/bazaar@" + bazaarHash + "/stage/themes.json"
	resp, reqErr := request.SetResult(&result).Get(u)
	if nil != reqErr {
		logging.LogErrorf("get community stage index [%s] failed: %s", u, reqErr)
		return
	}
	if 200 != resp.StatusCode {
		logging.LogErrorf("get community stage index [%s] failed: %d", u, resp.StatusCode)
		return
	}

	repos := result["repos"].([]interface{})
	waitGroup := &sync.WaitGroup{}
	lock := &sync.Mutex{}
	p, _ := ants.NewPoolWithFunc(8, func(arg interface{}) {
		defer waitGroup.Done()

		repo := arg.(map[string]interface{})
		repoURL := repo["url"].(string)

		theme := &Theme{}
		innerU := util.BazaarOSSServer + "/package/" + repoURL + "/theme.json"
		innerResp, innerErr := httpclient.NewBrowserRequest().SetResult(theme).Get(innerU)
		if nil != innerErr {
			logging.LogErrorf("get bazaar package [%s] failed: %s", innerU, innerErr)
			return
		}
		if 200 != innerResp.StatusCode {
			logging.LogErrorf("get bazaar package [%s] failed: %d", innerU, resp.StatusCode)
			return
		}

		repoURLHash := strings.Split(repoURL, "@")
		theme.RepoURL = "https://github.com/" + repoURLHash[0]
		theme.RepoHash = repoURLHash[1]
		theme.PreviewURL = util.BazaarOSSServer + "/package/" + repoURL + "/preview.png?imageslim"
		theme.PreviewURLThumb = util.BazaarOSSServer + "/package/" + repoURL + "/preview.png?imageView2/2/w/436/h/232"
		theme.Updated = repo["updated"].(string)
		theme.Stars = int(repo["stars"].(float64))
		theme.OpenIssues = int(repo["openIssues"].(float64))
		theme.Size = int64(repo["size"].(float64))
		theme.HSize = humanize.Bytes(uint64(theme.Size))
		theme.HUpdated = formatUpdated(theme.Updated)
		pkg := bazaarIndex[strings.Split(repoURL, "@")[0]]
		if nil != pkg {
			theme.Downloads = pkg.Downloads
		}
		lock.Lock()
		ret = append(ret, theme)
		lock.Unlock()
	})
	for _, repo := range repos {
		waitGroup.Add(1)
		p.Invoke(repo)
	}
	waitGroup.Wait()
	p.Release()

	sort.Slice(ret, func(i, j int) bool { return ret[i].Updated > ret[j].Updated })
	return
}

func InstalledThemes() (ret []*Theme) {
	dir, err := os.Open(util.ThemesPath)
	if nil != err {
		logging.LogWarnf("open appearance themes folder [%s] failed: %s", util.ThemesPath, err)
		return
	}
	themeDirs, err := dir.Readdir(-1)
	if nil != err {
		logging.LogWarnf("read appearance themes folder failed: %s", err)
		return
	}
	dir.Close()

	for _, themeDir := range themeDirs {
		if !themeDir.IsDir() {
			continue
		}
		dirName := themeDir.Name()
		if isBuiltInTheme(dirName) {
			continue
		}

		themeConf, parseErr := ThemeJSON(dirName)
		if nil != parseErr || nil == themeConf {
			continue
		}

		theme := &Theme{}
		theme.Name = themeConf["name"].(string)
		theme.Author = themeConf["author"].(string)
		theme.URL = themeConf["url"].(string)
		theme.Version = themeConf["version"].(string)
		theme.Modes = make([]string, 0, len(themeConf["modes"].([]interface{})))
		theme.RepoURL = theme.URL
		theme.PreviewURL = "/appearance/themes/" + dirName + "/preview.png"
		theme.PreviewURLThumb = "/appearance/themes/" + dirName + "/preview.png"
		theme.Updated = themeDir.ModTime().Format("2006-01-02 15:04:05")
		theme.Size = themeDir.Size()
		theme.HSize = humanize.Bytes(uint64(theme.Size))
		theme.HUpdated = formatUpdated(theme.Updated)
		readme, readErr := os.ReadFile(filepath.Join(util.ThemesPath, dirName, "README.md"))
		if nil != readErr {
			logging.LogWarnf("read install theme README.md failed: %s", readErr)
			continue
		}
		theme.README = gulu.Str.FromBytes(readme)

		if !existThemes(ret, theme) {
			ret = append(ret, theme)
		}
	}
	return
}

func isBuiltInTheme(dirName string) bool {
	return "daylight" == dirName || "midnight" == dirName
}

func existThemes(themes []*Theme, theme *Theme) bool {
	for _, t := range themes {
		if t.Name == theme.Name {
			return true
		}
	}
	return false
}

func InstallTheme(repoURL, repoHash, installPath string, systemID string) error {
	repoURLHash := repoURL + "@" + repoHash
	data, err := downloadPackage(repoURLHash, true, systemID)
	if nil != err {
		return err
	}
	return installPackage(data, installPath)
}

func UninstallTheme(installPath string) error {
	if err := os.RemoveAll(installPath); nil != err {
		logging.LogErrorf("remove theme [%s] failed: %s", installPath, err)
		return errors.New("remove community theme failed")
	}
	//logging.Logger.Infof("uninstalled theme [%s]", installPath)
	return nil
}

func ThemeJSON(themeName string) (ret map[string]interface{}, err error) {
	p := filepath.Join(util.ThemesPath, themeName, "theme.json")
	if !gulu.File.IsExist(p) {
		err = os.ErrNotExist
		return
	}
	data, err := os.ReadFile(p)
	if nil != err {
		logging.LogErrorf("read theme.json [%s] failed: %s", p, err)
		return
	}
	if err = gulu.JSON.UnmarshalJSON(data, &ret); nil != err {
		logging.LogErrorf("parse theme.json [%s] failed: %s", p, err)
		return
	}
	if 5 > len(ret) {
		logging.LogWarnf("invalid theme.json [%s]", p)
		return nil, errors.New("invalid theme.json")
	}
	return
}