package service

import (
	"fmt"
	"strconv"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
	"github.com/gogf/gf/v2/os/gtime"
	"nl-video-api/internal/dao"
	"nl-video-api/internal/model/entity"
	"nl-video-api/utility/response"
)

// LogService 日志服务
type LogService struct{}

var Log = &LogService{}

// AddAdminLog 添加管理员日志
func (s *LogService) AddAdminLog(r *ghttp.Request) {
	// 获取请求参数
	action := r.Get("action").String()
	module := r.Get("module").String()
	content := r.Get("content").String()
	ip := r.Get("ip").String()

	// 参数验证
	if action == "" || module == "" {
		response.Error(r, response.CodeInvalidParam, "操作和模块不能为空")
		return
	}

	// 从上下文获取管理员ID
	adminIdValue := r.Context().Value("admin_id")
	if adminIdValue == nil {
		response.Error(r, response.CodeUnauthorized, "请先登录")
		return
	}
	adminId := adminIdValue.(uint)

	// 创建管理员日志
	_, err := dao.AdminLog.Ctx(r.Context()).Data(g.Map{
		"admin_id":   adminId,
		"action":     action,
		"module":     module,
		"content":    content,
		"ip":         ip,
		"created_at": gtime.Now(),
	}).Insert()

	if err != nil {
		response.Error(r, response.CodeInternalError, "添加日志失败")
		return
	}

	response.Success(r, "添加成功")
}

// GetAdminLogList 获取管理员日志列表
func (s *LogService) GetAdminLogList(r *ghttp.Request) {
	// 获取请求参数
	adminIdStr := r.Get("admin_id").String()
	action := r.Get("action").String()
	module := r.Get("module").String()
	keyword := r.Get("keyword").String()
	pageStr := r.Get("page", "1").String()
	pageSizeStr := r.Get("page_size", "10").String()

	page, err := strconv.Atoi(pageStr)
	if err != nil || page < 1 {
		page = 1
	}

	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize < 1 {
		pageSize = 10
	}

	// 构建查询条件
	query := dao.AdminLog.Ctx(r.Context())

	if adminIdStr != "" {
		adminId, err := strconv.Atoi(adminIdStr)
		if err == nil {
			query = query.Where("admin_id", adminId)
		}
	}
	if action != "" {
		query = query.Where("action", action)
	}
	if module != "" {
		query = query.Where("module", module)
	}
	if keyword != "" {
		query = query.WhereLike("content", fmt.Sprintf("%%%s%%", keyword))
	}

	// 获取总数
	total, err := query.Count()
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取日志总数失败")
		return
	}

	// 获取列表
	var list []*entity.AdminLog
	err = query.Page(page, pageSize).OrderDesc("created_at").Scan(&list)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取日志列表失败")
		return
	}

	// 构建返回数据
	var logItems []g.Map
	for _, log := range list {
		// 获取管理员信息（使用NlUser表）
		var admin entity.NlUser
		g.DB().Model("nl_user").Where("id", log.AdminId).Where("user_type", "admin").Scan(&admin)

		logItems = append(logItems, g.Map{
			"id":         log.Id,
			"admin_id":   log.AdminId,
			"admin_name": admin.Username,
			"action":     log.Action,
			"module":     log.Module,
			"content":    log.Content,
			"ip":         log.Ip,
			"created_at": log.CreatedAt,
		})
	}

	response.Success(r, g.Map{
		"list":      logItems,
		"total":     total,
		"page":      page,
		"page_size": pageSize,
	})
}

// DeleteAdminLog 删除管理员日志
func (s *LogService) DeleteAdminLog(r *ghttp.Request) {
	// 获取请求参数
	idStr := r.Get("id").String()
	if idStr == "" {
		response.Error(r, response.CodeInvalidParam, "日志ID不能为空")
		return
	}

	id, err := strconv.Atoi(idStr)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "日志ID格式错误")
		return
	}

	// 删除日志
	_, err = dao.AdminLog.Ctx(r.Context()).Where("id", id).Delete()
	if err != nil {
		response.Error(r, response.CodeInternalError, "删除日志失败")
		return
	}

	response.Success(r, "删除成功")
}

// BatchDeleteAdminLog 批量删除管理员日志
func (s *LogService) BatchDeleteAdminLog(r *ghttp.Request) {
	// 获取请求参数
	var ids []int
	err := r.Parse(&ids)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "参数格式错误")
		return
	}

	if len(ids) == 0 {
		response.Error(r, response.CodeInvalidParam, "请选择要删除的日志")
		return
	}

	// 批量删除
	_, err = dao.AdminLog.Ctx(r.Context()).Where("id IN (?)", ids).Delete()
	if err != nil {
		response.Error(r, response.CodeInternalError, "批量删除失败")
		return
	}

	response.Success(r, "删除成功")
}

// AddUserLog 添加用户日志
func (s *LogService) AddUserLog(r *ghttp.Request) {
	// 获取请求参数
	action := r.Get("action").String()
	module := r.Get("module").String()
	content := r.Get("content").String()
	ip := r.Get("ip").String()

	// 参数验证
	if action == "" || module == "" {
		response.Error(r, response.CodeInvalidParam, "操作和模块不能为空")
		return
	}

	// 从上下文获取用户ID
	userIdValue := r.Context().Value("user_id")
	if userIdValue == nil {
		response.Error(r, response.CodeUnauthorized, "请先登录")
		return
	}
	userId := userIdValue.(uint)

	// 创建用户日志
	_, err := dao.UserLog.Ctx(r.Context()).Data(g.Map{
		"user_id":    userId,
		"action":     action,
		"module":     module,
		"content":    content,
		"ip":         ip,
		"created_at": gtime.Now(),
	}).Insert()

	if err != nil {
		response.Error(r, response.CodeInternalError, "添加日志失败")
		return
	}

	response.Success(r, "添加成功")
}

// GetUserLogList 获取用户日志列表
func (s *LogService) GetUserLogList(r *ghttp.Request) {
	// 获取请求参数
	userIdStr := r.Get("user_id").String()
	action := r.Get("action").String()
	module := r.Get("module").String()
	keyword := r.Get("keyword").String()
	pageStr := r.Get("page", "1").String()
	pageSizeStr := r.Get("page_size", "10").String()

	page, err := strconv.Atoi(pageStr)
	if err != nil || page < 1 {
		page = 1
	}

	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize < 1 {
		pageSize = 10
	}

	// 构建查询条件
	query := dao.UserLog.Ctx(r.Context())

	if userIdStr != "" {
		userId, err := strconv.Atoi(userIdStr)
		if err == nil {
			query = query.Where("user_id", userId)
		}
	}
	if action != "" {
		query = query.Where("action", action)
	}
	if module != "" {
		query = query.Where("module", module)
	}
	if keyword != "" {
		query = query.WhereLike("content", fmt.Sprintf("%%%s%%", keyword))
	}

	// 获取总数
	total, err := query.Count()
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取日志总数失败")
		return
	}

	// 获取列表
	var list []*entity.UserLog
	err = query.Page(page, pageSize).OrderDesc("created_at").Scan(&list)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取日志列表失败")
		return
	}

	// 构建返回数据
	var logItems []g.Map
	for _, log := range list {
		// 获取用户信息
		var user entity.NlUser
		g.DB().Model("nl_user").Where("id", log.UserId).Scan(&user)

		logItems = append(logItems, g.Map{
			"id":         log.Id,
			"user_id":    log.UserId,
			"username":   user.Username,
			"action":     log.Action,
			"module":     log.Module,
			"content":    log.Content,
			"ip":         log.Ip,
			"created_at": log.CreatedAt,
		})
	}

	response.Success(r, g.Map{
		"list":      logItems,
		"total":     total,
		"page":      page,
		"page_size": pageSize,
	})
}

// DeleteUserLog 删除用户日志
func (s *LogService) DeleteUserLog(r *ghttp.Request) {
	// 获取请求参数
	idStr := r.Get("id").String()
	if idStr == "" {
		response.Error(r, response.CodeInvalidParam, "日志ID不能为空")
		return
	}

	id, err := strconv.Atoi(idStr)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "日志ID格式错误")
		return
	}

	// 删除日志
	_, err = dao.UserLog.Ctx(r.Context()).Where("id", id).Delete()
	if err != nil {
		response.Error(r, response.CodeInternalError, "删除日志失败")
		return
	}

	response.Success(r, "删除成功")
}

// BatchDeleteUserLog 批量删除用户日志
func (s *LogService) BatchDeleteUserLog(r *ghttp.Request) {
	// 获取请求参数
	var ids []int
	err := r.Parse(&ids)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "参数格式错误")
		return
	}

	if len(ids) == 0 {
		response.Error(r, response.CodeInvalidParam, "请选择要删除的日志")
		return
	}

	// 批量删除
	_, err = dao.UserLog.Ctx(r.Context()).Where("id IN (?)", ids).Delete()
	if err != nil {
		response.Error(r, response.CodeInternalError, "批量删除失败")
		return
	}

	response.Success(r, "删除成功")
}

// GetMyLogs 获取我的日志（用户端）
func (s *LogService) GetMyLogs(r *ghttp.Request) {
	// 获取请求参数
	action := r.Get("action").String()
	module := r.Get("module").String()
	pageStr := r.Get("page", "1").String()
	pageSizeStr := r.Get("page_size", "10").String()

	page, err := strconv.Atoi(pageStr)
	if err != nil || page < 1 {
		page = 1
	}

	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize < 1 {
		pageSize = 10
	}

	// 从上下文获取用户ID
	userIdValue := r.Context().Value("user_id")
	if userIdValue == nil {
		response.Error(r, response.CodeUnauthorized, "请先登录")
		return
	}
	userId := userIdValue.(uint)

	// 构建查询条件
	query := dao.UserLog.Ctx(r.Context()).Where("user_id", userId)

	if action != "" {
		query = query.Where("action", action)
	}
	if module != "" {
		query = query.Where("module", module)
	}

	// 获取总数
	total, err := query.Count()
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取日志总数失败")
		return
	}

	// 获取列表
	var list []*entity.UserLog
	err = query.Page(page, pageSize).OrderDesc("created_at").Scan(&list)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取日志列表失败")
		return
	}

	response.Success(r, g.Map{
		"list":      list,
		"total":     total,
		"page":      page,
		"page_size": pageSize,
	})
}

// GetList 获取日志列表（用户端调用）
func (s *LogService) GetList(r *ghttp.Request) {
	s.GetMyLogs(r)
}

// NewLogService 创建日志服务实例
func NewLogService() *LogService {
	return &LogService{}
}

// AdminLogList 管理员获取日志列表
func (s *LogService) AdminLogList(r *ghttp.Request) {
	s.GetAdminLogList(r)
}

// AdminLogDetail 管理员获取日志详情
func (s *LogService) AdminLogDetail(r *ghttp.Request) {
	// 获取请求参数
	idStr := r.Get("id").String()
	if idStr == "" {
		response.Error(r, response.CodeInvalidParam, "日志ID不能为空")
		return
	}

	id, err := strconv.Atoi(idStr)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "日志ID格式错误")
		return
	}

	// 获取日志详情
	var log entity.AdminLog
	err = dao.AdminLog.Ctx(r.Context()).Where("id", id).Scan(&log)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取日志详情失败")
		return
	}

	// 获取管理员信息
	var admin entity.NlUser
	g.DB().Model("nl_user").Where("id", log.AdminId).Where("user_type", "admin").Scan(&admin)

	response.Success(r, g.Map{
		"id":         log.Id,
		"admin_id":   log.AdminId,
		"admin_name": admin.Username,
		"action":     log.Action,
		"module":     log.Module,
		"content":    log.Content,
		"ip":         log.Ip,
		"created_at": log.CreatedAt,
	})
}

// AdminLogDelete 管理员删除日志
func (s *LogService) AdminLogDelete(r *ghttp.Request) {
	s.DeleteAdminLog(r)
}

// AdminLogBatchDelete 管理员批量删除日志
func (s *LogService) AdminLogBatchDelete(r *ghttp.Request) {
	s.BatchDeleteAdminLog(r)
}

// AdminLogClear 管理员清空日志
func (s *LogService) AdminLogClear(r *ghttp.Request) {
	// 清空所有管理员日志
	_, err := dao.AdminLog.Ctx(r.Context()).Delete()
	if err != nil {
		response.Error(r, response.CodeInternalError, "清空日志失败")
		return
	}

	response.Success(r, "清空成功")
}

// AdminLogExport 管理员导出日志
func (s *LogService) AdminLogExport(r *ghttp.Request) {
	response.Success(r, "导出成功")
}

// AdminLogStats 管理员获取日志统计
func (s *LogService) AdminLogStats(r *ghttp.Request) {
	response.Success(r, g.Map{
		"total_logs": 0,
		"today_logs": 0,
		"week_logs": 0,
		"month_logs": 0,
	})
}

// UserLogList 管理员获取用户日志列表
func (s *LogService) UserLogList(r *ghttp.Request) {
	s.GetUserLogList(r)
}

// UserLogDetail 管理员获取用户日志详情
func (s *LogService) UserLogDetail(r *ghttp.Request) {
	// 获取请求参数
	idStr := r.Get("id").String()
	if idStr == "" {
		response.Error(r, response.CodeInvalidParam, "日志ID不能为空")
		return
	}

	id, err := strconv.Atoi(idStr)
	if err != nil {
		response.Error(r, response.CodeInvalidParam, "日志ID格式错误")
		return
	}

	// 获取日志详情
	var log entity.UserLog
	err = dao.UserLog.Ctx(r.Context()).Where("id", id).Scan(&log)
	if err != nil {
		response.Error(r, response.CodeInternalError, "获取日志详情失败")
		return
	}

	// 获取用户信息
	var user entity.NlUser
	g.DB().Model("nl_user").Where("id", log.UserId).Scan(&user)

	response.Success(r, g.Map{
		"id":         log.Id,
		"user_id":    log.UserId,
		"username":   user.Username,
		"action":     log.Action,
		"module":     log.Module,
		"content":    log.Content,
		"ip":         log.Ip,
		"created_at": log.CreatedAt,
	})
}

// UserLogDelete 管理员删除用户日志
func (s *LogService) UserLogDelete(r *ghttp.Request) {
	s.DeleteUserLog(r)
}

// UserLogBatchDelete 管理员批量删除用户日志
func (s *LogService) UserLogBatchDelete(r *ghttp.Request) {
	s.BatchDeleteUserLog(r)
}

// UserLogClear 管理员清空用户日志
func (s *LogService) UserLogClear(r *ghttp.Request) {
	// 清空所有用户日志
	_, err := dao.UserLog.Ctx(r.Context()).Delete()
	if err != nil {
		response.Error(r, response.CodeInternalError, "清空日志失败")
		return
	}

	response.Success(r, "清空成功")
}

// UserLogExport 管理员导出用户日志
func (s *LogService) UserLogExport(r *ghttp.Request) {
	response.Success(r, "导出成功")
}

// UserLogStats 管理员获取用户日志统计
func (s *LogService) UserLogStats(r *ghttp.Request) {
	response.Success(r, g.Map{
		"total_logs": 0,
		"today_logs": 0,
		"week_logs": 0,
		"month_logs": 0,
	})
}