package controllers

import (
    "CRTProject/models"
    "CRTProject/services"
    "fmt"
    jwt "github.com/appleboy/gin-jwt/v2"
    "github.com/gin-gonic/contrib/sessions"
    "github.com/gin-gonic/gin"
    "github.com/sirupsen/logrus"
    "golang.org/x/crypto/bcrypt"
    "log"
    "time"
)

type Router struct {
    Router   *gin.Engine
    Database *services.DatabaseService

    UserController UserController
}

func (r *Router) Start() {
    r.Router = gin.New()
    r.Router.Use(sessions.Sessions("supersecretsession", sessions.NewCookieStore([]byte("secret"))))

    r.Database = &services.DatabaseService{}
    if !r.Database.Boot() {
        return
    }

    r.UserController = UserController{r.Database}
    var jwtMiddleware = r.JwtMiddleware()

    authGroup := r.Router.Group("/auth")
    authGroup.GET("/refresh_token", jwtMiddleware.LoginHandler)
    authGroup.POST("/login", jwtMiddleware.LoginHandler)

    apiGroup := r.Router.Group("/api")
    apiGroup.Use(jwtMiddleware.MiddlewareFunc())
    {
        apiGroup.GET("/users", r.UserController.GetUsers)
        apiGroup.GET("/user", r.UserController.GetUser)
        apiGroup.GET("/test", r.Simple_test)
    }

    err := r.Router.Run(":8000")
    if err != nil {
        logrus.Errorf("Can't start backend! Error: %s\n", err.Error())
        return
    }
}

func (r *Router) Simple_test(c *gin.Context) {
    claims := jwt.ExtractClaims(c)
    user, _ := c.Get(identityKey)
    c.JSON(200, gin.H{
        identityKey : claims[identityKey],
        "claims_all" : claims,
        "user" : user,

    })
}

var identityKey = "username"
func (r *Router) JwtMiddleware() *jwt.GinJWTMiddleware {
    m, err := jwt.New(&jwt.GinJWTMiddleware{
        Realm:      "CRT",
        Key:        []byte("supersecretkey"),
        Timeout:    time.Minute * 50, // TODO : change this value
        MaxRefresh: time.Minute * 50, // TODO : change this value
        IdentityKey: identityKey,
        PayloadFunc: func(data interface{}) jwt.MapClaims {
            if v, ok := data.(*models.User); ok {
                log.Printf("%v", v)
                return jwt.MapClaims{
                    identityKey: v.Username,
                }
            }
            return jwt.MapClaims{}
        },
        IdentityHandler: func(c *gin.Context) interface{} {
            claims := jwt.ExtractClaims(c)
            log.Printf("%v", claims)
            log.Printf("%v", claims["IdentityKey"])
            return &models.User{
                Username: fmt.Sprintf("%v", claims[identityKey]),
            }
        },
        //Authenticator: r.Authenticator,
        Authenticator: func(c *gin.Context) (interface{}, error) {
            var credentials = struct {
                Login    string `form:"login" json:"login" binding:"required"`
                Password string `form:"password" json:"password" binding:"required"`
            }{}

            if err := c.ShouldBind(&credentials); err != nil {
                return "", jwt.ErrMissingLoginValues
            }

            var userModel models.User
            r.Database.DB.Where(models.User{Login: credentials.Login}).First(&userModel)
            if userModel.ID == 0 {
                return "", jwt.ErrFailedAuthentication
            }
            err := bcrypt.CompareHashAndPassword([]byte(userModel.Password), []byte(credentials.Password))
            if err != nil {
                return "", jwt.ErrFailedAuthentication
            }
            return userModel, nil
        },
        Authorizator: func(data interface{}, c *gin.Context) bool {
            if _, ok := data.(*models.User); ok {
                return true
            }
            return false
        },
        Unauthorized: func(c *gin.Context, code int, message string) {
            c.JSON(code, gin.H{
                "code":    code,
                "message": message,
            })
        },
        TokenLookup: "header: Authorization, query: token, cookie: jwt",
        TokenHeadName: "Bearer",
        TimeFunc: time.Now,
    },
    )

    if err != nil {
        logrus.Errorf("Can't wake up JWT Middleware! Error: %s\n", err.Error())
        return nil
    }

    errInit := m.MiddlewareInit()
    if errInit != nil {
        logrus.Errorf("Can't init JWT Middleware! Error: %s\n", errInit.Error())
        return nil
    }

    return m
}