package repository

import (
	"encoding/base64"
	"os"
	"path"
	"time"

	"next-terminal/server/config"
	"next-terminal/server/constant"
	"next-terminal/server/model"
	"next-terminal/server/utils"

	"gorm.io/gorm"
)

type SessionRepository struct {
	DB *gorm.DB
}

func NewSessionRepository(db *gorm.DB) *SessionRepository {
	sessionRepository = &SessionRepository{DB: db}
	return sessionRepository
}

func (r SessionRepository) Find(pageIndex, pageSize int, status, userId, clientIp, assetId, protocol string) (results []model.SessionForPage, total int64, err error) {

	db := r.DB
	var params []interface{}

	params = append(params, status)

	itemSql := "SELECT s.id,s.mode, s.protocol,s.recording, s.connection_id, s.asset_id, s.creator, s.client_ip, s.width, s.height, s.ip, s.port, s.username, s.status, s.connected_time, s.disconnected_time,s.code, s.message, a.name AS asset_name, u.nickname AS creator_name FROM sessions s LEFT JOIN assets a ON s.asset_id = a.id LEFT JOIN users u ON s.creator = u.id WHERE s.STATUS = ? "
	countSql := "select count(*) from sessions as s where s.status = ? "

	if len(userId) > 0 {
		itemSql += " and s.creator = ?"
		countSql += " and s.creator = ?"
		params = append(params, userId)
	}

	if len(clientIp) > 0 {
		itemSql += " and s.client_ip like ?"
		countSql += " and s.client_ip like ?"
		params = append(params, "%"+clientIp+"%")
	}

	if len(assetId) > 0 {
		itemSql += " and s.asset_id = ?"
		countSql += " and s.asset_id = ?"
		params = append(params, assetId)
	}

	if len(protocol) > 0 {
		itemSql += " and s.protocol = ?"
		countSql += " and s.protocol = ?"
		params = append(params, protocol)
	}

	params = append(params, (pageIndex-1)*pageSize, pageSize)
	itemSql += " order by s.connected_time desc LIMIT ?, ?"

	db.Raw(countSql, params...).Scan(&total)

	err = db.Raw(itemSql, params...).Scan(&results).Error

	if results == nil {
		results = make([]model.SessionForPage, 0)
	}
	return
}

func (r SessionRepository) FindByStatus(status string) (o []model.Session, err error) {
	err = r.DB.Where("status = ?", status).Find(&o).Error
	return
}

func (r SessionRepository) FindByStatusIn(statuses []string) (o []model.Session, err error) {
	err = r.DB.Where("status in ?", statuses).Find(&o).Error
	return
}

func (r SessionRepository) FindOutTimeSessions(dayLimit int) (o []model.Session, err error) {
	limitTime := time.Now().Add(time.Duration(-dayLimit*24) * time.Hour)
	err = r.DB.Where("status = ? and connected_time < ?", constant.Disconnected, limitTime).Find(&o).Error
	return
}

func (r SessionRepository) Create(o *model.Session) (err error) {
	err = r.DB.Create(o).Error
	return
}

func (r SessionRepository) FindById(id string) (o model.Session, err error) {
	err = r.DB.Where("id = ?", id).First(&o).Error
	return
}

func (r SessionRepository) FindByIdAndDecrypt(id string) (o model.Session, err error) {
	err = r.DB.Where("id = ?", id).First(&o).Error
	if err == nil {
		err = r.Decrypt(&o)
	}
	return
}

func (r SessionRepository) Decrypt(item *model.Session) error {
	if item.Password != "" && item.Password != "-" {
		origData, err := base64.StdEncoding.DecodeString(item.Password)
		if err != nil {
			return err
		}
		decryptedCBC, err := utils.AesDecryptCBC(origData, config.GlobalCfg.EncryptionPassword)
		if err != nil {
			return err
		}
		item.Password = string(decryptedCBC)
	}
	if item.PrivateKey != "" && item.PrivateKey != "-" {
		origData, err := base64.StdEncoding.DecodeString(item.PrivateKey)
		if err != nil {
			return err
		}
		decryptedCBC, err := utils.AesDecryptCBC(origData, config.GlobalCfg.EncryptionPassword)
		if err != nil {
			return err
		}
		item.PrivateKey = string(decryptedCBC)
	}
	if item.Passphrase != "" && item.Passphrase != "-" {
		origData, err := base64.StdEncoding.DecodeString(item.Passphrase)
		if err != nil {
			return err
		}
		decryptedCBC, err := utils.AesDecryptCBC(origData, config.GlobalCfg.EncryptionPassword)
		if err != nil {
			return err
		}
		item.Passphrase = string(decryptedCBC)
	}
	return nil
}

func (r SessionRepository) FindByConnectionId(connectionId string) (o model.Session, err error) {
	err = r.DB.Where("connection_id = ?", connectionId).First(&o).Error
	return
}

func (r SessionRepository) UpdateById(o *model.Session, id string) error {
	o.ID = id
	return r.DB.Updates(o).Error
}

func (r SessionRepository) UpdateWindowSizeById(width, height int, id string) error {
	session := model.Session{}
	session.Width = width
	session.Height = height

	return r.UpdateById(&session, id)
}

func (r SessionRepository) DeleteById(id string) error {
	return r.DB.Where("id = ?", id).Delete(&model.Session{}).Error
}

func (r SessionRepository) DeleteByIds(sessionIds []string) error {
	recordingPath := config.GlobalCfg.Guacd.Recording
	for i := range sessionIds {
		if err := os.RemoveAll(path.Join(recordingPath, sessionIds[i])); err != nil {
			return err
		}
		if err := r.DeleteById(sessionIds[i]); err != nil {
			return err
		}
	}
	return nil
}

func (r SessionRepository) DeleteByStatus(status string) error {
	return r.DB.Where("status = ?", status).Delete(&model.Session{}).Error
}

func (r SessionRepository) CountOnlineSession() (total int64, err error) {
	err = r.DB.Where("status = ?", constant.Connected).Find(&model.Session{}).Count(&total).Error
	return
}

func (r SessionRepository) EmptyPassword() error {
	sql := "update sessions set password = '-',private_key = '-', passphrase = '-' where 1=1"
	return r.DB.Exec(sql).Error
}

func (r SessionRepository) CountByStatus(status string) (total int64, err error) {
	err = r.DB.Find(&model.Session{}).Where("status = ?", status).Count(&total).Error
	return
}

func (r SessionRepository) OverviewAccess(account model.User) (o []model.SessionForAccess, err error) {
	db := r.DB
	if constant.TypeUser == account.Type {
		sql := "SELECT s.asset_id, s.ip, s.port, s.protocol, s.username, count(s.asset_id) AS access_count FROM sessions AS s where s.creator = ? GROUP BY s.asset_id, s.ip, s.port, s.protocol, s.username ORDER BY access_count DESC limit 10"
		err = db.Raw(sql, []string{account.ID}).Scan(&o).Error
	} else {
		sql := "SELECT s.asset_id, s.ip, s.port, s.protocol, s.username, count(s.asset_id) AS access_count FROM sessions AS s GROUP BY s.asset_id, s.ip, s.port, s.protocol, s.username ORDER BY access_count DESC limit 10"
		err = db.Raw(sql).Scan(&o).Error
	}
	if o == nil {
		o = make([]model.SessionForAccess, 0)
	}
	return
}