// Package handlers provides the http functionality for the URL Shortener
package handlers

import (
	"html/template"
	"net/http"
	"time"

	"github.com/sirupsen/logrus"

	"github.com/gin-gonic/gin"
	"github.com/mxschmitt/golang-url-shortener/handlers/tmpls"
	"github.com/mxschmitt/golang-url-shortener/stores"
	"github.com/mxschmitt/golang-url-shortener/util"
	"github.com/pkg/errors"
)

// Handler holds the funcs and attributes for the
// http communication
type Handler struct {
	store     stores.Store
	engine    *gin.Engine
	providers []string
}

// DoNotPrivateKeyChecking is used for testing
var DoNotPrivateKeyChecking = false

type loggerEntryWithFields interface {
	WithFields(fields logrus.Fields) *logrus.Entry
}

// Ginrus returns a gin.HandlerFunc (middleware) that logs requests using logrus.
//
// Requests with errors are logged using logrus.Error().
// Requests without errors are logged using logrus.Info().
//
// It receives:
//   1. A time package format string (e.g. time.RFC3339).
//   2. A boolean stating whether to use UTC time zone or local.
//   3. Optionally, a list of paths to skip logging for (this is why
//      we are not using upstream github.com/gin-gonic/contrib/ginrus)
func Ginrus(logger loggerEntryWithFields, timeFormat string, utc bool, notlogged ...string) gin.HandlerFunc {
	var skip map[string]struct{}
	if length := len(notlogged); length > 0 {
		skip = make(map[string]struct{}, length)
		for _, path := range notlogged {
			skip[path] = struct{}{}
		}
	}

	return func(c *gin.Context) {
		start := time.Now()
		// some evil middlewares modify this values
		path := c.Request.URL.Path
		c.Next()

		// log only when path is not being skipped
		if _, ok := skip[path]; !ok {
			end := time.Now()
			latency := end.Sub(start)
			if utc {
				end = end.UTC()
			}

			entry := logger.WithFields(logrus.Fields{
				"status":     c.Writer.Status(),
				"method":     c.Request.Method,
				"path":       path,
				"ip":         c.ClientIP(),
				"latency":    latency,
				"user-agent": c.Request.UserAgent(),
				"time":       end.Format(timeFormat),
			})

			if len(c.Errors) > 0 {
				// Append error field if this is an erroneous request.
				entry.Error(c.Errors.String())
			} else {
				entry.Info()
			}
		}
	}
}

// New initializes the http handlers
func New(store stores.Store) (*Handler, error) {
	if !util.GetConfig().EnableDebugMode {
		gin.SetMode(gin.ReleaseMode)
	}
	h := &Handler{
		store:  store,
		engine: gin.New(),
	}
	if err := h.setHandlers(); err != nil {
		return nil, errors.Wrap(err, "could not set handlers")
	}
	if util.GetConfig().AuthBackend == "oauth" {
		if !DoNotPrivateKeyChecking {
			if err := util.CheckForPrivateKey(); err != nil {
				return nil, errors.Wrap(err, "could not check for private key")
			}
		}
		h.initOAuth()
	} else if util.GetConfig().AuthBackend == "proxy" {
		h.initProxyAuth()
	}
	return h, nil
}

func (h *Handler) addTemplatesFromFS(files []string) error {
	var t *template.Template
	for _, file := range files {
		fileContent, err := tmpls.FSString(false, "/"+file)
		if err != nil {
			return errors.Wrap(err, "could not read template file")
		}
		if t == nil {
			t, err = template.New(file).Parse(fileContent)
			if err != nil {
				return errors.Wrap(err, "could not create template from file content")
			}
			continue
		}
		if _, err := t.New(file).Parse(fileContent); err != nil {
			return errors.Wrap(err, "could not parse template")
		}
	}
	h.engine.SetHTMLTemplate(t)
	return nil
}

func (h *Handler) setHandlers() error {
	if err := h.addTemplatesFromFS([]string{"token.html", "protected.html"}); err != nil {
		return errors.Wrap(err, "could not add templates from FS")
	}
	// only do web access logs if enabled
	if util.GetConfig().EnableAccessLogs {
		if util.GetConfig().EnableDebugMode {
			// in debug mode, log everything including healthchecks
			h.engine.Use(Ginrus(logrus.StandardLogger(), time.RFC3339, false))
		} else {
			// if we are not in debug mode, do not log healthchecks
			h.engine.Use(Ginrus(logrus.StandardLogger(), time.RFC3339, false, "/ok"))
		}
	}
	protected := h.engine.Group("/api/v1/protected")
	if util.GetConfig().AuthBackend == "oauth" {
		logrus.Info("Using OAuth auth backend")
		protected.Use(h.oAuthMiddleware)
	} else if util.GetConfig().AuthBackend == "proxy" {
		logrus.Info("Using proxy auth backend")
		protected.Use(h.proxyAuthMiddleware)
	} else {
		logrus.Fatalf("Auth backend method '%s' is not recognized", util.GetConfig().AuthBackend)
	}
	protected.POST("/create", h.handleCreate)
	protected.POST("/lookup", h.handleLookup)
	protected.GET("/recent", h.handleRecent)
	protected.POST("/visitors", h.handleGetVisitors)

	h.engine.GET("/api/v1/info", h.handleInfo)
	h.engine.GET("/d/:id/:hash", h.handleDelete)
	h.engine.GET("/ok", h.handleHealthcheck)

	// Handling the shorted URLs, if no one exists, it checks
	// in the filesystem and sets headers for caching
	h.engine.NoRoute(h.handleAccess, func(c *gin.Context) {
		c.Header("Vary", "Accept-Encoding")
		c.Header("Cache-Control", "public, max-age=2592000")
		c.Header("ETag", util.VersionInfo.Commit)
	}, gin.WrapH(http.FileServer(FS(false))))
	return nil
}

// Listen starts the http server
func (h *Handler) Listen() error {
	return h.engine.Run(util.GetConfig().ListenAddr)
}

// CloseStore stops the http server and the closes the db gracefully
func (h *Handler) CloseStore() error {
	return h.store.Close()
}