/*
=================================================================================
* License: GPL-2.0 license
* Author: 众产®  https://ciy.cn/code
* Version: 0.1.3
=================================================================================
Web服务器	NewCiyWebServer
=================================================================================

=================================================================================
示例:

=================================================================================
Nginx配置示例:

=================================================================================
*/
package zciyon

import (
	"context"
	"fmt"
	"net"
	"net/http"
	"net/http/fcgi"
	"net/http/httputil"
	"net/url"
	"os"
	"path/filepath"
	"runtime"
	"strings"
)

type CiyWebServer struct {
	pathfn   map[string]map[string]func(http.ResponseWriter, *http.Request) bool
	mock     func(http.ResponseWriter, *http.Request) error //Mock回调
	phpproxy *httputil.ReverseProxy                         //PHP代理服务器
	exts     map[string]int                                 //静态服务器允许的扩展名，不设置全部允许
}

type contextKey string

var GhttpKey contextKey = contextKey("ciy")

type RequestContext struct {
	CiyAuth string
}

//在根上建立HandleFunc
//

func NewCiyWebServer() (*CiyWebServer, error) {
	web := &CiyWebServer{}
	web.exts = map[string]int{}
	web.pathfn = map[string]map[string]func(http.ResponseWriter, *http.Request) bool{}
	http.HandleFunc("/", web.WithRequestContext(web.runMainPath))
	http.HandleFunc("/ws/", web.runWebsocket)
	return web, nil
}
func (web *CiyWebServer) WithRequestContext(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		ctx := context.WithValue(r.Context(), GhttpKey, &RequestContext{
			CiyAuth: "",
		})
		next(w, r.WithContext(ctx))
	}
}
func (thos *CiyWebServer) registerPath(path, fnname string, fn func(http.ResponseWriter, *http.Request) bool) {
	_, ok := thos.pathfn[path]
	if ok {
		thos.pathfn[path][fnname] = fn
	} else {
		thos.pathfn[path] = map[string]func(http.ResponseWriter, *http.Request) bool{fnname: fn}
	}
}
func (thos *CiyWebServer) SetExt(extstr string) { //允许的静态文件类型 .jpg;.png。不设置全部允许
	exts := strings.Split(extstr, ";")
	for _, ext := range exts {
		ext = strings.ToLower(strings.TrimSpace(ext))
		if !strings.HasPrefix(ext, ".") {
			continue
		}
		thos.exts[ext] = 1
	}
}
func (thos *CiyWebServer) runWebsocket(w http.ResponseWriter, r *http.Request) {
	funname := GetQuery("func", r)
	Clog("websocket", funname)
	clsmothod := strings.Split(funname, ".")
	if len(clsmothod) != 2 {
		Clog("websocket", fmt.Sprintf("func format error:%v", funname))
		return
	}
	for path := range thos.pathfn {
		if path == clsmothod[0] {
			for fnname, fn := range thos.pathfn[path] {
				if clsmothod[1] == fnname {
					fn(w, r)
					return
				}
			}
			Clog("websocket", fmt.Sprintf("RouterFunc not find mothod[%v] in [%v]", clsmothod[1], clsmothod[0]))
			return
		}
	}
	Clog("RouterFunc not find class:%v", clsmothod[0])
}
func (thos *CiyWebServer) runMainPath(w http.ResponseWriter, r *http.Request) {
	Clog("root", r.URL.Path)
	//将大于n毫秒的请求，保存到log
	//可以统计每个path.func的请求次数用时
	rets := make([]string, 0)
	if err := thos.execFunc(w, r); err == nil {
		return
	} else {
		rets = append(rets, err.Error())
	}
	if thos.mock != nil {
		if err := thos.execMock(w, r); err == nil {
			return
		} else {
			rets = append(rets, err.Error())
		}
	}
	if thos.phpproxy != nil {
		if err := thos.execPHP(w, r); err == nil {
			return
		} else {
			rets = append(rets, err.Error())
		}
	}
	if CiyRunMode == CIYRUN_DEV {
		ErrJSON(w, strings.Join(rets, "; "), nil)
	} else {
		http.NotFound(w, r)
	}
}
func (thos *CiyWebServer) execMock(w http.ResponseWriter, r *http.Request) error {
	Clog("execMock", r.URL.Path)
	//找文件或数据库mocks，若有返回。
	return thos.mock(w, r)
}
func (thos *CiyWebServer) execPHP(w http.ResponseWriter, r *http.Request) error {
	Clog("execPHP", r.URL.Path)
	//找本地goc文件，若有转发请求。
	//找到 func指向的.php文件是否存在，打开文件检查是否存在public static function json_xxx()   static function sse_xxx(
	thos.phpproxy.ServeHTTP(w, r)
	return nil
}
func (thos *CiyWebServer) execFunc(w http.ResponseWriter, r *http.Request) error {
	defer func() {
		if rc := recover(); rc != nil {
			funname := r.URL.Path
			if funname == "" {
				funname = GetQuery("sse", r)
			}
			errmsg := fmt.Sprintf("%v", rc)
			Log.Error(funname, errmsg)
			ErrJSON(w, errmsg)
		}
	}()
	Clog("execFunc", r.URL.Path)
	clsmothod := strings.Split(r.URL.Path, ".")
	if len(clsmothod) != 2 {
		return fmt.Errorf("RouterFunc format error:%v", r.URL.Path)
	}
	for path := range thos.pathfn {
		if path == clsmothod[0] {
			for fnname, fn := range thos.pathfn[path] {
				if clsmothod[1] == fnname {
					sttime := Timems()
					boo := fn(w, r)
					CiyVars.Func_runms += Timems() - sttime
					if boo {
						CiyVars.Func_succ++
					} else {
						CiyVars.Func_fail++
					}
					return nil
				}
			}
			return fmt.Errorf("RouterFunc not find mothod[%v] in [%v]", clsmothod[1], clsmothod[0])
		}
	}
	return fmt.Errorf("RouterFunc not find class:%v", clsmothod[0])
}
func (thos *CiyWebServer) runStatic(w http.ResponseWriter, r *http.Request) bool {

	Clog("runStatic", r.URL.Path)
	//模拟nginx功能
	//判断文件扩展名是否允许

	//判断文件@参数，如果无缓存则压缩图片，存到文件缓存，返回文件缓存地址

	//文件在10分钟内，被访问超过n次，则进入内存缓存。
	//缓存达到容量后，自动清理10分钟内访问次数最少的几个文件缓存
	//如果文件扩展名包含
	file := CiyWebDir + r.URL.Path
	if len(thos.exts) > 0 {
		ext := strings.ToLower(filepath.Ext(file))
		if ext != "" {
			if _, ok := thos.exts[ext]; !ok {
				http.NotFound(w, r)
				return false
			}
		}
	}
	err := FileExist(file)
	if err != nil {
		http.NotFound(w, r)
	}
	http.ServeFile(w, r, file)
	return true
}
func (thos *CiyWebServer) RouterStatic(path string) { //允许的静态目录
	thos.registerPath(path, "", thos.runStatic)
}
func (thos *CiyWebServer) RouterFunc(path string, fnmap map[string]map[string]func(http.ResponseWriter, *http.Request) bool) {
	for subpath, fnmap2 := range fnmap {
		for funstr, fn := range fnmap2 {
			thos.registerPath(path+"/"+subpath, funstr, fn)
		}
	}
}

func (thos *CiyWebServer) RouterHandle(path string, fn func(http.ResponseWriter, *http.Request)) {
	http.HandleFunc(path, fn)
}
func (thos *CiyWebServer) SetPHP(host string) {
	if host == "" {
		return
	}
	if ind := strings.Index(host, "://"); ind > -1 {
		host = host[ind+3:]
	}
	thos.phpproxy = httputil.NewSingleHostReverseProxy(
		&url.URL{
			Scheme: "http",
			Host:   host,
		},
	)
	_, err := http.Get("http://" + host)
	if err != nil {
		Clog("WebRun PHP err:", err)
		return
	}
	Clog("WebRun support PHP:", host)
}
func (thos *CiyWebServer) execMockFile(w http.ResponseWriter, r *http.Request) error {
	funname := r.URL.Path
	mockfile := CiyWebDir + "/ud/mock/" + funname + ".json"
	err := FileExist(mockfile)
	if err != nil {
		return err
	}
	http.ServeFile(w, r, mockfile)
	return nil
}
func (thos *CiyWebServer) SetMockFile() {
	if thos.mock != nil {
		return
	}
	thos.mock = thos.execMockFile
	Clog("WebRun support Mock File")
}
func (thos *CiyWebServer) SetMockFn(fn func(http.ResponseWriter, *http.Request) error) {
	if thos.mock != nil {
		return
	}
	thos.mock = fn
	Clog("WebRun support Mock Callback")
}

func (thos *CiyWebServer) Run(mode, ipsk string) {
	if mode == "fastcgi" {
		listener, err := net.Listen("tcp", ipsk)
		if err != nil {
			Clog("WebRun fastcgi listen err:", err)
			return
		}
		defer listener.Close()
		Clog("WebRun fastcgi running: " + ipsk)
		err = fcgi.Serve(listener, nil)
		if err != nil {
			Clog("WebRun fastcgi err:", err)
			return
		}
	} else if mode == "unixsock" {
		// sigchan := make(chan os.Signal, 1)
		// signal.Notify(sigchan, os.Interrupt)
		// signal.Notify(sigchan, syscall.SIGTERM)

		var sockf string
		switch runtime.GOOS {
		case "linux":
			sockf = "/run/" + ipsk
		default:
			Clog("WebRun unixsock err: unknown system " + runtime.GOOS)
			return
		}
		os.Remove(sockf)
		listener, err := net.Listen("unix", sockf)
		if err != nil {
			Clog("WebRun unixsock listen err:", err)
			return
		}
		defer listener.Close()
		Clog("WebRun unixsock running: " + sockf)
		err = fcgi.Serve(listener, nil)
		if err != nil {
			Clog("WebRun unixsock err:", err)
			return
		}
		// <-sigchan
		// os.Remove(sockf)
	} else {
		Clog("WebRun http running: " + ipsk)
		err := http.ListenAndServe(ipsk, nil)
		if err != nil {
			Clog("WebRun http err:", err)
			return
		}
	}
}
func (thos *CiyWebServer) RunHTTP2(parm string) {
	if parm == "" {
		return
	}
	parms := strings.Split(parm, ",")
	if len(parms) != 3 {
		Clog("WebRun http2 param err:", parm)
	}
	err := http.ListenAndServeTLS(parms[0], parms[1], parms[2], nil)
	if err != nil {
		Clog("WebRun http2 err:", err)
	}
	Clog("WebRun http2 running: " + parm)
}

func GetQuery(key string, r *http.Request) string {
	query := r.URL.Query()
	if query[key] == nil {
		return ""
	}
	return query[key][0]
}
func ErrJSON(w http.ResponseWriter, errmsg string, argext ...any) bool {
	jsn := map[string]any{
		"errmsg": errmsg,
	}
	var err error
	if len(argext) > 0 {
		for i, v := range argext {
			if i == 0 {
				if daterr, ok := v.(error); ok {
					err = daterr
					continue
				}
			}
			if datint, ok := v.(int); ok {
				if datint != 1 {
					jsn["code"] = datint
				}
			} else if datmap, ok := v.(map[string]any); ok {
				for key, val := range datmap {
					if key != "code" {
						jsn[key] = val
					}
				}
			}
		}
	}
	if err != nil {
		Log.Info("ErrJSON", errmsg+":"+err.Error())
	}
	w.Write(JSON_Byte(jsn))
	return false
}
func SuccJSON(w http.ResponseWriter, r *http.Request, obj ...map[string]any) bool {
	jsn := map[string]any{
		"code": 1,
	}
	for _, kv := range obj {
		for k, v := range kv {
			if k != "code" {
				jsn[k] = v
			}
		}
	}
	reqCtx := r.Context().Value(GhttpKey).(*RequestContext)
	if reqCtx != nil && reqCtx.CiyAuth != "" {
		jsn["_ciyauth"] = reqCtx.CiyAuth
	}
	w.Write(JSON_Byte(jsn))
	return true
}