package controllers

import (
	"fmt"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	"go-crud/initializers"
	"go-crud/models"

	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt/v4"
	"golang.org/x/crypto/bcrypt"
	"gorm.io/gorm"
)

func SignUp(c *gin.Context) {
	var body struct {
		Email       string
		Password    string
		Nik         string
		Name        string
		Photo       string
		Birthdate   time.Time
		JobTitle    string
		CreatedBy   string
		UpdatedBy   string
		DeletedBy   string
	}

	if err := c.ShouldBindJSON(&body); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Failed to read body",
		})
		return
	}

	hash, err := bcrypt.GenerateFromPassword([]byte(body.Password), 10)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Failed to generate password hash",
		})
		return
	}

	user := models.User{
		Email:       body.Email,
		Password:    string(hash),
		Nik:         body.Nik,
		Name:        body.Name,
		Photo:       body.Photo,
		Birthdate:   body.Birthdate,
		JobTitle:    body.JobTitle,
		LastLoginAt: time.Now(),
		CreatedBy:   body.Nik,
		UpdatedBy:   body.Nik,
		DeletedBy:   body.Nik,
		Token:       "",
	}

	result := initializers.DB.Create(&user)

	if result.Error != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Failed to create user",
		})
		return
	}

	updateLoginRecord(c, user.ID, time.Now())

	c.JSON(http.StatusOK, gin.H{})
}

func LogIn(c *gin.Context) {
	var body struct {
		Email    string
		Password string
	}
	if err := c.ShouldBindJSON(&body); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Failed to read body",
		})
		return
	}

	var user models.User
	initializers.DB.First(&user, "email = ?", body.Email)
	if user.ID == 0 {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Invalid email or password",
		})
		return
	}

	err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(body.Password))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Invalid email or password",
		})
		return
	}

	user.LastLoginAt = time.Now()
	initializers.DB.Save(&user)

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"sub": user.ID,
		"exp": time.Now().Add(time.Hour * 24 * 30).Unix(),
	})

	tokenString, err := token.SignedString([]byte(os.Getenv("SECRET")))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "Failed to create token",
		})
		return
	}

	c.SetSameSite(http.SameSiteLaxMode)
	c.SetCookie("Authorization", tokenString, 3600*24*30, "", "", false, true)
	c.JSON(http.StatusOK, gin.H{
		"token": tokenString,
	})

	updateLoginRecord(c, user.ID, time.Now())
}


func LogOut(c *gin.Context) {
	c.SetCookie("Authorization", "", -1, "/", "", false, true)

	c.JSON(http.StatusOK, gin.H{
		"message": "Logout successful",
	})
}

func Validate(c *gin.Context) {
	user, _ := c.Get("user")

	c.JSON(http.StatusOK, gin.H{
		"message": user,
	})
}


func updateLoginRecord(c *gin.Context, userID uint, date time.Time) {
	// Cari data rekap login berdasarkan tanggal
	var loginRecord models.LoginRecord
	result := initializers.DB.Where("login_date = ?", date.Format("2006-01-02")).First(&loginRecord)

	if result.Error != nil && result.Error != gorm.ErrRecordNotFound {
		return
	}

	if result.Error == gorm.ErrRecordNotFound {
		// Jika belum ada data rekap untuk hari ini, buat data baru
		loginRecord = models.LoginRecord{
			LoginDate: date,
			UserIDs:   fmt.Sprintf("%d", userID),
		}
		initializers.DB.Create(&loginRecord)
	} else {
		// Jika sudah ada data rekap, cek apakah user sudah login pada hari ini
		if !containsInt(loginRecord.UserIDs, userID) {
			// Jika user belum login hari ini, tambahkan ID pengguna ke dalam array user_ids
			loginRecord.UserIDs = fmt.Sprintf("%s,%d", loginRecord.UserIDs, userID)
			initializers.DB.Save(&loginRecord)
		}
	}

	// Ambil data pengguna yang login pada hari ini
	var users []models.User
	initializers.DB.Find(&users, "id IN (?)", parseUserIDs(loginRecord.UserIDs))

	// Update login record dengan pengguna yang login pada hari ini
	loginRecord.Users = users

	initializers.DB.Save(&loginRecord)

	// Update LastLoginAt pada tabel User jika dalam satu hari user melakukan login kembali
	user := models.User{}
	initializers.DB.First(&user, userID)
	user.LastLoginAt = date
	initializers.DB.Save(&user)
}


// Helper function to check if an int is present in a slice
func containsInt(slice string, val uint) bool {
	ids := parseUserIDs(slice)
	for _, item := range ids {
		if item == val {
			return true
		}
	}
	return false
}

// Helper function to parse user IDs from a string
func parseUserIDs(idsStr string) []uint {
	ids := strings.Split(idsStr, ",")
	var userIDs []uint
	for _, idStr := range ids {
		id, err := strconv.ParseUint(idStr, 10, 32)
		if err != nil {
			continue
		}
		userIDs = append(userIDs, uint(id))
	}
	return userIDs
}

func GetLoginRecords(c *gin.Context) {
    var loginRecords []models.LoginRecord
    result := initializers.DB.Find(&loginRecords)

    if result.Error != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "code":    http.StatusInternalServerError,
            "data":    nil,
            "message": "Failed to fetch login records",
            "status":  false,
            "totalRecord": 0,
        })
        return
    }

    // Retrieve user details for each login record
    for i := range loginRecords {
        var users []models.User
        initializers.DB.Find(&users, "id IN (?)", parseUserIDs(loginRecords[i].UserIDs))

        loginRecords[i].Users = users
    }

    // Create JSON response
    var response struct {
        Code       int              `json:"code"`
        Data       []models.LoginRecord `json:"data"`
        Message    string           `json:"message"`
        Status     bool             `json:"status"`
        TotalRecord int              `json:"totalRecord"`
    }

    response.Code = http.StatusOK
    response.Data = loginRecords
    response.Message = "OK"
    response.Status = true
    response.TotalRecord = len(loginRecords)

    c.JSON(http.StatusOK, response)
}