package FlyAPIs

import (
	"errors"
	"net/http"

	"gitee.com/flyiot/flylibs/FlyJSON"
)

type FlyApiServerBasicInterface interface {
	Handle(pattern string, handler http.Handler)
	HandleFunc(string, func(http.ResponseWriter, *http.Request))
}

type FlyApiServer struct {
	Settings  *FlyApiSettings
	Server    *http.Server
	ServerMux *http.ServeMux
	Ready     bool
}

func NewFlyApiServer() *FlyApiServer {
	s := FlyApiServer{}
	s.Settings = NewFlyApiSettings()
	s.ServerMux = http.NewServeMux()
	return &s
}

// 从ini加载配置信息
func (s *FlyApiServer) Open(settings *FlyApiSettings) error {
	s.LoadSettings(settings)
	return s.Start()
}

func (s *FlyApiServer) LoadSettings(settings *FlyApiSettings) {
	s.Settings = settings
}

func (s *FlyApiServer) Start() error {
	s.Ready = false

	if !s.Settings.Ready {
		return errors.New("settings error")
	}
	if !s.Settings.Enable {
		return errors.New("not enable")
	}

	if s.ServerMux == nil {
		s.ServerMux = http.NewServeMux()
	}

	s.Server = &http.Server{
		Addr:    s.Settings.Addr,
		Handler: s.ServerMux,
	}

	go func() {
		log.Info("Start Api Server: " + s.Settings.Addr)
		if err := s.Server.ListenAndServe(); err != nil {
			log.ErrorExit(2, "Fail to start http server", err)
		}
	}()

	s.Ready = true
	return nil
}

// func (s *FlyApiServer) handler(w http.ResponseWriter, r *http.Request) {
// 	if r.URL.Path == "/hello" {
// 		fmt.Fprintf(w, "Hello from server 1!\n")
// 	} else {
// 		fmt.Fprintf(w, "Invalid request on server 1\n")
// 	}
// }

func (s *FlyApiServer) Handle(pattern string, handler http.Handler) {
	s.ServerMux.Handle(pattern, handler)
}

func (s *FlyApiServer) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
	s.ServerMux.HandleFunc(pattern, handler)
}

func (s *FlyApiServer) HandleApi(pattern string, handler func(*FlyApi) any) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = log.Error(r)
		}
	}()

	s.ServerMux.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				log.Warn(err)
			}
		}()
		if origin := r.Header.Get("Origin"); origin != "" {
			w.Header().Set("Access-Control-Allow-Origin", origin)
			w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE")
			w.Header().Set("Access-Control-Allow-Credentials", "true")
			w.Header().Set("Access-Control-Allow-Headers",
				"Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
		}
		if r.Method == "OPTIONS" {
			return
		}
		w.Header().Set("cache-control", "no-cache, no-store, must-revalidate")
		w.Header().Set("expires", "0")

		api := NewFlyApi(w, r, *s.Settings)

		if s.Settings.Token != "" {
			tk := api.V("token", "")
			if tk != s.Settings.Token {
				if json, err := FlyJSON.MinAPI().Marshal(api.Err("Token Error")); err == nil {
					w.Header().Set("content-type", "application/json")
					w.WriteHeader(http.StatusOK)
					w.Write(json)

				} else {
					w.Write([]byte("error"))

				}
			}
		}

		resp := handler(api)
		switch v := resp.(type) {
		case nil:
			w.WriteHeader(http.StatusOK)

		case string:
			w.WriteHeader(http.StatusOK)
			w.Write([]byte(v))
		case []byte:
			w.WriteHeader(http.StatusOK)
			w.Write(v)
		default:
			if json, err := FlyJSON.MinAPI().Marshal(resp); err == nil {
				w.Header().Set("content-type", "application/json")
				w.WriteHeader(http.StatusOK)
				w.Write(json)
			} else {
				w.Write([]byte("error"))
				log.Warn(err)
			}

		}
	})
	return nil
}