package service

import (
	"context"
	"kra/internal/biz"
)

type AuditService struct{ uc *biz.AuditUsecase }

func NewAuditService(uc *biz.AuditUsecase) *AuditService { return &AuditService{uc: uc} }
func (s *AuditService) RecordOperation(ctx context.Context, v *biz.OperationRecord) error {
	return s.uc.Repo().RecordOperation(ctx, v)
}
func (s *AuditService) RecordLogin(ctx context.Context, v *biz.LoginLog) error {
	return s.uc.Repo().RecordLogin(ctx, v)
}
func (s *AuditService) RecordDataAccess(ctx context.Context, v *biz.DataAccessLog) error {
	return s.uc.Repo().RecordDataAccess(ctx, v)
}
func opDTO(v *biz.OperationRecord) map[string]any {
	return map[string]any{"ID": v.ID, "CreatedAt": v.CreatedAt, "DeletedAt": nil, "ip": v.IP, "method": v.Method, "path": v.Path, "status": v.Status, "latency_ms": v.LatencyMS, "agent": v.Agent, "error_message": v.ErrorMessage, "body": v.Body, "resp": v.Response, "user_id": v.UserID, "request_id": v.RequestID, "trace_id": v.TraceID, "device_id": v.DeviceID, "user": nil}
}
func loginDTO(v *biz.LoginLog) map[string]any {
	return map[string]any{"ID": v.ID, "CreatedAt": v.CreatedAt, "DeletedAt": nil, "username": v.Username, "ip": v.IP, "status": v.Status, "errorMessage": v.ErrorMessage, "agent": v.Agent, "userId": v.UserID, "user": nil}
}
func dataAccessDTO(v *biz.DataAccessLog) map[string]any {
	return map[string]any{"ID": v.ID, "CreatedAt": v.CreatedAt, "DeletedAt": nil, "eventType": v.EventType, "targetTable": v.TargetTable, "operation": v.Operation, "userId": v.UserID, "authorityId": v.AuthorityID, "scope": v.Scope, "requestId": v.RequestID, "method": v.Method, "path": v.Path, "detail": v.Detail}
}
func (s *AuditService) Operations(ctx context.Context, page, size int, q *biz.OperationRecord) ([]map[string]any, int64, error) {
	items, total, err := s.uc.Repo().ListOperations(ctx, page, size, q)
	if err != nil {
		return nil, 0, err
	}
	out := make([]map[string]any, 0, len(items))
	for _, v := range items {
		out = append(out, opDTO(v))
	}
	return out, total, nil
}
func (s *AuditService) Operation(ctx context.Context, id uint) (map[string]any, error) {
	v, err := s.uc.Repo().FindOperation(ctx, id)
	if err != nil {
		return nil, err
	}
	return opDTO(v), nil
}
func (s *AuditService) DeleteOperations(ctx context.Context, ids []uint) error {
	return s.uc.Repo().DeleteOperations(ctx, ids)
}
func (s *AuditService) Logins(ctx context.Context, page, size int, q *biz.LoginLog) ([]map[string]any, int64, error) {
	items, total, err := s.uc.Repo().ListLogins(ctx, page, size, q)
	if err != nil {
		return nil, 0, err
	}
	out := make([]map[string]any, 0, len(items))
	for _, v := range items {
		out = append(out, loginDTO(v))
	}
	return out, total, nil
}
func (s *AuditService) Login(ctx context.Context, id uint) (map[string]any, error) {
	v, err := s.uc.Repo().FindLogin(ctx, id)
	if err != nil {
		return nil, err
	}
	return loginDTO(v), nil
}
func (s *AuditService) DeleteLogins(ctx context.Context, ids []uint) error {
	return s.uc.Repo().DeleteLogins(ctx, ids)
}
func (s *AuditService) DataAccess(ctx context.Context, page, size int, q *biz.DataAccessLog) ([]map[string]any, int64, error) {
	items, total, err := s.uc.Repo().ListDataAccess(ctx, page, size, q)
	if err != nil {
		return nil, 0, err
	}
	out := make([]map[string]any, 0, len(items))
	for _, v := range items {
		out = append(out, dataAccessDTO(v))
	}
	return out, total, nil
}
func (s *AuditService) DeleteDataAccess(ctx context.Context, ids []uint) error {
	return s.uc.Repo().DeleteDataAccess(ctx, ids)
}
func (s *AuditService) LogDates(ctx context.Context, month string) (map[string]any, error) {
	items, err := s.uc.Repo().LogDates(ctx, month)
	if err != nil {
		return nil, err
	}
	out := make([]map[string]any, 0, len(items))
	for _, v := range items {
		out = append(out, map[string]any{"date": v.Date, "fileCount": v.FileCount})
	}
	return map[string]any{"month": month, "dates": out}, nil
}
func (s *AuditService) LogFiles(ctx context.Context, date string) (map[string]any, error) {
	items, err := s.uc.Repo().LogFiles(ctx, date)
	if err != nil {
		return nil, err
	}
	out := make([]map[string]any, 0, len(items))
	for _, v := range items {
		out = append(out, map[string]any{"path": v.Path, "name": v.Name, "size": v.Size, "modifiedAt": v.ModifiedAt})
	}
	return map[string]any{"date": date, "files": out}, nil
}
func (s *AuditService) LogContent(ctx context.Context, date, path string, cursor *int64) (map[string]any, error) {
	v, err := s.uc.Repo().LogContent(ctx, date, path, cursor)
	if err != nil {
		return nil, err
	}
	return map[string]any{"date": v.Date, "path": v.Path, "content": v.Content, "lineCount": v.LineCount, "nextCursor": v.NextCursor, "hasMore": v.HasMore, "limitedByBytes": v.LimitedByBytes, "size": v.Size, "modifiedAt": v.ModifiedAt}, nil
}
func errorDTO(v *biz.ErrorRecord) map[string]any {
	return map[string]any{"ID": v.ID, "CreatedAt": v.CreatedAt, "DeletedAt": nil, "form": v.Form, "info": v.Info, "level": v.Level, "request_id": v.RequestID, "trace_id": v.TraceID, "solution": v.Solution, "status": v.Status}
}
func (s *AuditService) CreateError(ctx context.Context, v *biz.ErrorRecord) error {
	return s.uc.Repo().CreateError(ctx, v)
}
func (s *AuditService) UpdateError(ctx context.Context, v *biz.ErrorRecord) error {
	return s.uc.Repo().UpdateError(ctx, v)
}
func (s *AuditService) DeleteErrors(ctx context.Context, ids []uint) error {
	return s.uc.Repo().DeleteErrors(ctx, ids)
}
func (s *AuditService) Error(ctx context.Context, id uint) (map[string]any, error) {
	v, err := s.uc.Repo().FindError(ctx, id)
	if err != nil {
		return nil, err
	}
	return errorDTO(v), nil
}
func (s *AuditService) Errors(ctx context.Context, page, size int, q *biz.ErrorRecord) ([]map[string]any, int64, error) {
	items, total, err := s.uc.Repo().ListErrors(ctx, page, size, q)
	if err != nil {
		return nil, 0, err
	}
	out := make([]map[string]any, 0, len(items))
	for _, v := range items {
		out = append(out, errorDTO(v))
	}
	return out, total, nil
}