package auth

import (
	"context"
	"fmt"
	"strconv"
	"time"

	"sismedika.com/sas/westone/types"
	"sismedika.com/sas/westone/utils"
)

func (s *Store) SignInWestone(email string, password string) (*types.User, error) {
	user := new(types.User)

	qry := `
		SELECT
		M_UserID,
		M_UserName,
		M_UserGroupDashboard,
		M_StaffName,
		10000000 as time_autologout
		FROM m_user
		JOIN m_usergroup ON M_UserM_UserGroupID = M_UserGroupID
		LEFT JOIN m_staff on M_UserM_StaffID = M_StaffID
		WHERE M_UserName = ? AND M_UserPassword = ? AND M_UserIsActive = 'Y'
	`
	if err := s.db.Get(user, qry, email, password); err != nil {
		return nil, &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "AUTH",
			Params:    "email: " + email,
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}
	user.Type_Akun = "westone"

	return user, nil
}

func (s *Store) LogSignIn(email string, ip string, status string, tipe string, provider string) error {
	tx, err := s.db.BeginTxx(context.Background(), nil)
	if err != nil {
		return err
	}

	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()

	logval := types.LogLogin{
		LogLoginMUserEmail: email,
		LogLoginDateTime:   time.Now().Format("2006-01-02 15:04:05"),
		LogLoginIP:         ip,
		LogLoginType:       tipe,
		LogLoginStatus:     status,
		LogLoginLogin:      provider,
	}

	qry := `INSERT INTO log_login
			(Log_LoginM_UserEmail, Log_LoginDateTime, Log_LoginIP, Log_LoginType, Log_LoginStatus, Log_LoginLogin)
	VALUES (:Log_LoginM_UserEmail, :Log_LoginDateTime, :Log_LoginIP, :Log_LoginType, :Log_LoginStatus, :Log_LoginLogin)`

	_, err = tx.NamedExec(qry, logval)
	if err != nil {
		return &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "LOG AUTH",
			Params:    "email: " + email,
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}

	if err = tx.Commit(); err != nil {
		return &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "LOG AUTH",
			Params:    "email: " + email,
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}

	return nil
}
func (s *Store) LogRISLogin(userID int, userAgent string, userName string, message string, status string) error {
	tx, err := s.db.BeginTxx(context.Background(), nil)
	if err != nil {
		return err
	}

	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()
	logval := types.LogRISLogin{
		LogLoginM_UserID:  strconv.Itoa(userID),
		LogLoginDateTime:  time.Now().Format("2006-01-02 15:04:05"),
		LogLoginUserAgent: userAgent,
		LogLoginUserName:  userName,
		LogLoginMessage:   message,
		LogLoginStatus:    status,
	}

	qry := `INSERT INTO log_login
			(Log_LoginM_UserID, Log_LoginDateTime, Log_LoginUserAgent, Log_LoginUserName, Log_LoginMessage, Log_LoginStatus)
	VALUES (:Log_LoginM_UserID, :Log_LoginDateTime, :Log_LoginUserAgent, :Log_LoginUserName, :Log_LoginMessage, :Log_LoginStatus)`

	_, err = tx.NamedExec(qry, logval)
	if err != nil {
		return &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "LOG AUTH",
			Params:    "userName: " + userName,
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}

	if err = tx.Commit(); err != nil {
		return &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "LOG AUTH",
			Params:    "userName: " + userName,
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}

	return nil
}
func (s *Store) UpdateUserToken(userID int, token string) error {
	tx, err := s.db.BeginTxx(context.Background(), nil)
	if err != nil {
		return &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "LOG AUTH",
			Params:    "",
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}

	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()

	qrySys := `SELECT Conf_SystemIsAutoLogOut, Conf_SystemAutoLogOutDuration FROM conf_system LIMIT 1`
	var isAutoLogOut string
	var autoLogOutDuration int
	err = s.db.QueryRow(qrySys).Scan(&isAutoLogOut, &autoLogOutDuration)
	if err != nil {
		return &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "AUTH",
			Params:    "",
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}

	expiredDate := time.Now().Add(time.Duration(autoLogOutDuration) * time.Minute)

	qry := `UPDATE m_user SET M_UserToken = :token, M_UserExpiredToken = :expiredDate WHERE M_UserID = :userID`

	_, err = tx.NamedExec(qry, map[string]interface{}{
		"token":       token,
		"userID":      userID,
		"expiredDate": expiredDate.Format("2006-01-02 15:04:05"),
	})
	// fmt.Println("err", err)
	if err != nil {
		return &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "LOG AUTH",
			Params:    "",
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}

	if err = tx.Commit(); err != nil {
		return &utils.LogError{
			Code:      "151",
			TraceID:   utils.RandomTraceID(15),
			Type:      "LOG AUTH",
			Params:    "",
			Query:     "-",
			Message:   err.Error(),
			TimeStamp: time.Now().Format("2006-01-02 15:04:05"),
		}
	}

	return nil
}
func (s *Store) UpdateExpiredToken(token string) error {
	// fmt.Printf("Masuk expired token")
	tx, err := s.db.BeginTxx(context.Background(), nil)
	if err != nil {
		return fmt.Errorf("failed to begin transaction: %v", err)
	}

	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()

	qrySys := `SELECT Conf_SystemIsAutoLogOut, Conf_SystemAutoLogOutDuration FROM conf_system LIMIT 1`
	var isAutoLogOut string
	var autoLogOutDuration int
	err = s.db.QueryRow(qrySys).Scan(&isAutoLogOut, &autoLogOutDuration)
	if err != nil {
		return fmt.Errorf("failed to get system config: %v", err)
	}

	if isAutoLogOut == "Y" {
		qryEt := `SELECT DATE_FORMAT(M_UserExpiredToken, '%Y-%m-%d %H:%i:%s') as M_UserExpiredToken FROM m_user WHERE M_UserToken = ?`

		var expiredToken string
		err = s.db.Get(&expiredToken, qryEt, token)
		if err != nil {
			return fmt.Errorf("failed to get expired token: %v", err)
		}

		timeNow := time.Now().Format("2006-01-02 15:04:05")

		expiredTime, err := time.Parse("2006-01-02 15:04:05", expiredToken)
		if err != nil {
			return fmt.Errorf("failed to parse expired token: %v", err)
		}

		timeNowParsed, err := time.Parse("2006-01-02 15:04:05", timeNow)
		if err != nil {
			return fmt.Errorf("failed to parse current time: %v", err)
		}

		if timeNowParsed.After(expiredTime) {
			fmt.Printf("timenow: %v, expiredTime: %v", timeNow, expiredTime)
			// fmt.Println("token expired")
			return fmt.Errorf("token expired")
		} else {
			// fmt.Println("token belum expired")
			fmt.Printf("timenow: %v, expiredTime: %v", timeNow, expiredTime)

		}

		timeNowAdd := timeNowParsed.Add(time.Duration(autoLogOutDuration) * time.Minute)
		qryUpdateExpiredToken := `UPDATE m_user SET M_UserExpiredToken = ? WHERE M_UserToken = ?`
		_, err = tx.Exec(qryUpdateExpiredToken, timeNowAdd.Format("2006-01-02 15:04:05"), token)
		if err != nil {
			return fmt.Errorf("failed to update expired token: %v", err)
		}

		if err = tx.Commit(); err != nil {
			return fmt.Errorf("failed to commit transaction: %v", err)
		}
	}

	return nil
}
func (s *Store) UpdateExpiredTokenBu(userID int) error {
	fmt.Printf("Masuk expired token")
	tx, err := s.db.BeginTxx(context.Background(), nil)
	if err != nil {
		return fmt.Errorf("failed to begin transaction: %v", err)
	}

	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()

	qrySys := `SELECT Conf_SystemIsAutoLogOut, Conf_SystemAutoLogOutDuration FROM conf_system LIMIT 1`
	var isAutoLogOut string
	var autoLogOutDuration int
	err = s.db.QueryRow(qrySys).Scan(&isAutoLogOut, &autoLogOutDuration)
	if err != nil {
		return fmt.Errorf("failed to get system config: %v", err)
	}

	if isAutoLogOut == "Y" {
		qryEt := `SELECT DATE_FORMAT(M_UserExpiredToken, '%Y-%m-%d %H:%i:%s') as M_UserExpiredToken FROM m_user WHERE M_UserID = ?`

		var expiredToken string
		err = s.db.Get(&expiredToken, qryEt, userID)
		if err != nil {
			return fmt.Errorf("failed to get expired token: %v", err)
		}

		timeNow := time.Now().Format("2006-01-02 15:04:05")

		expiredTime, err := time.Parse("2006-01-02 15:04:05", expiredToken)
		if err != nil {
			return fmt.Errorf("failed to parse expired token: %v", err)
		}

		timeNowParsed, err := time.Parse("2006-01-02 15:04:05", timeNow)
		if err != nil {
			return fmt.Errorf("failed to parse current time: %v", err)
		}

		if timeNowParsed.After(expiredTime) {
			fmt.Printf("timenow: %v, expiredTime: %v", timeNow, expiredTime)
			fmt.Println("token expired")
			return fmt.Errorf("token expired")
		} else {
			fmt.Println("token belum expired")
			fmt.Printf("timenow: %v, expiredTime: %v", timeNow, expiredTime)

		}

		timeNowAdd := timeNowParsed.Add(time.Duration(autoLogOutDuration) * time.Minute)
		qryUpdateExpiredToken := `UPDATE m_user SET M_UserExpiredToken = ? WHERE M_UserID = ?`
		_, err = tx.Exec(qryUpdateExpiredToken, timeNowAdd.Format("2006-01-02 15:04:05"), userID)
		if err != nil {
			return fmt.Errorf("failed to update expired token: %v", err)
		}

		if err = tx.Commit(); err != nil {
			return fmt.Errorf("failed to commit transaction: %v", err)
		}
	}

	return nil
}