package hws

import (
	"errors"
	"fmt"
	"net/url"

	"git.haelnorr.com/h/golib/hlog"
	"github.com/gobwas/glob"
)

type logger struct {
	logger       *hlog.Logger
	ignoredPaths []glob.Glob
}

// LogError uses the attached logger to log a HWSError
func (s *Server) LogError(err HWSError) {
	if s.logger == nil {
		return
	}
	switch err.Level {
	case ErrorDEBUG:
		s.logger.logger.Debug().Err(err.Error).Msg(err.Message)
		return
	case ErrorINFO:
		s.logger.logger.Info().Err(err.Error).Msg(err.Message)
		return
	case ErrorWARN:
		s.logger.logger.Warn().Err(err.Error).Msg(err.Message)
		return
	case ErrorERROR:
		s.logger.logger.Error().Str("stacktrace", fmt.Sprintf("%+v", err.Error)).Err(err.Error).Msg(err.Message)
		return
	case ErrorFATAL:
		s.logger.logger.Fatal().Str("stacktrace", fmt.Sprintf("%+v", err.Error)).Err(err.Error).Msg(err.Message)
		return
	case ErrorPANIC:
		s.logger.logger.Panic().Str("stacktrace", fmt.Sprintf("%+v", err.Error)).Err(err.Error).Msg(err.Message)
		return
	default:
		s.logger.logger.Error().Str("stacktrace", fmt.Sprintf("%+v", err.Error)).Err(err.Error).Msg(err.Message)
	}
}

func (server *Server) LogFatal(err error) {
	if err == nil {
		err = errors.New("LogFatal was called with a nil error")
	}
	if server.logger == nil {
		fmt.Printf("FATAL - %s: %s", "A fatal error has occured", err.Error())
		return
	}
	server.logger.logger.Fatal().Err(err).Msg("A fatal error has occured")
}

// AddLogger adds a logger to the server to use for request logging.
func (server *Server) AddLogger(hlogger *hlog.Logger) error {
	if hlogger == nil {
		return errors.New("unable to add logger, no logger provided")
	}
	server.logger = &logger{
		logger: hlogger,
	}
	return nil
}

// LoggerIgnorePaths sets a list of URL paths to ignore logging for.
// Path should match the url.URL.Path field, see https://pkg.go.dev/net/url#URL
// Useful for ignoring requests to CSS files or favicons
func (server *Server) LoggerIgnorePaths(paths ...string) error {
	for _, path := range paths {
		u, err := url.Parse(path)
		valid := err == nil &&
			u.Scheme == "" &&
			u.Host == "" &&
			u.RawQuery == "" &&
			u.Fragment == ""
		if !valid {
			return fmt.Errorf("invalid path: '%s'", path)
		}
	}
	server.logger.ignoredPaths = prepareGlobs(paths)
	return nil
}

func prepareGlobs(paths []string) []glob.Glob {
	compiledGlobs := make([]glob.Glob, 0, len(paths))
	for _, pattern := range paths {
		g, err := glob.Compile(pattern)
		if err != nil {
			// If pattern fails to compile, skip it
			continue
		}
		compiledGlobs = append(compiledGlobs, g)
	}
	return compiledGlobs
}