package dto

import (
	"encoding/json"
	"time"

	"git.huangwc.com/pig/pig-farm-controller/internal/infra/models"
)

// --- General ---

// PaginationDTO 定义了分页信息的标准结构
type PaginationDTO struct {
	Total    int64 `json:"total"`
	Page     int   `json:"page"`
	PageSize int   `json:"pageSize"`
}

// --- SensorData ---

// ListSensorDataRequest 定义了获取传感器数据列表的请求参数
type ListSensorDataRequest struct {
	Page       int        `form:"page,default=1"`
	PageSize   int        `form:"pageSize,default=10"`
	DeviceID   *uint      `form:"device_id"`
	SensorType *string    `form:"sensor_type"`
	StartTime  *time.Time `form:"start_time" time_format:"rfc3339"`
	EndTime    *time.Time `form:"end_time" time_format:"rfc3339"`
	OrderBy    string     `form:"order_by"`
}

// SensorDataDTO 是用于API响应的传感器数据结构
type SensorDataDTO struct {
	Time                 time.Time         `json:"time"`
	DeviceID             uint              `json:"device_id"`
	RegionalControllerID uint              `json:"regional_controller_id"`
	SensorType           models.SensorType `json:"sensor_type"`
	Data                 json.RawMessage   `json:"data"`
}

// ListSensorDataResponse 是获取传感器数据列表的响应结构
type ListSensorDataResponse struct {
	List       []SensorDataDTO `json:"list"`
	Pagination PaginationDTO   `json:"pagination"`
}

// NewListSensorDataResponse 从模型数据创建列表响应 DTO
func NewListSensorDataResponse(data []models.SensorData, total int64, page, pageSize int) *ListSensorDataResponse {
	dtos := make([]SensorDataDTO, len(data))
	for i, item := range data {
		dtos[i] = SensorDataDTO{
			Time:                 item.Time,
			DeviceID:             item.DeviceID,
			RegionalControllerID: item.RegionalControllerID,
			SensorType:           item.SensorType,
			Data:                 json.RawMessage(item.Data),
		}
	}

	return &ListSensorDataResponse{
		List: dtos,
		Pagination: PaginationDTO{
			Total:    total,
			Page:     page,
			PageSize: pageSize,
		},
	}
}

// --- DeviceCommandLog ---

// ListDeviceCommandLogRequest 定义了获取设备命令日志列表的请求参数
type ListDeviceCommandLogRequest struct {
	Page            int        `form:"page,default=1"`
	PageSize        int        `form:"pageSize,default=10"`
	DeviceID        *uint      `form:"device_id"`
	ReceivedSuccess *bool      `form:"received_success"`
	StartTime       *time.Time `form:"start_time" time_format:"rfc3339"`
	EndTime         *time.Time `form:"end_time" time_format:"rfc3339"`
	OrderBy         string     `form:"order_by"`
}

// DeviceCommandLogDTO 是用于API响应的设备命令日志结构
type DeviceCommandLogDTO struct {
	MessageID       string     `json:"message_id"`
	DeviceID        uint       `json:"device_id"`
	SentAt          time.Time  `json:"sent_at"`
	AcknowledgedAt  *time.Time `json:"acknowledged_at"`
	ReceivedSuccess bool       `json:"received_success"`
}

// ListDeviceCommandLogResponse 是获取设备命令日志列表的响应结构
type ListDeviceCommandLogResponse struct {
	List       []DeviceCommandLogDTO `json:"list"`
	Pagination PaginationDTO         `json:"pagination"`
}

// NewListDeviceCommandLogResponse 从模型数据创建列表响应 DTO
func NewListDeviceCommandLogResponse(data []models.DeviceCommandLog, total int64, page, pageSize int) *ListDeviceCommandLogResponse {
	dtos := make([]DeviceCommandLogDTO, len(data))
	for i, item := range data {
		dtos[i] = DeviceCommandLogDTO{
			MessageID:       item.MessageID,
			DeviceID:        item.DeviceID,
			SentAt:          item.SentAt,
			AcknowledgedAt:  item.AcknowledgedAt,
			ReceivedSuccess: item.ReceivedSuccess,
		}
	}

	return &ListDeviceCommandLogResponse{
		List: dtos,
		Pagination: PaginationDTO{
			Total:    total,
			Page:     page,
			PageSize: pageSize,
		},
	}
}

// --- PlanExecutionLog ---

// ListPlanExecutionLogRequest 定义了获取计划执行日志列表的请求参数
type ListPlanExecutionLogRequest struct {
	Page      int        `form:"page,default=1"`
	PageSize  int        `form:"pageSize,default=10"`
	PlanID    *uint      `form:"plan_id"`
	Status    *string    `form:"status"`
	StartTime *time.Time `form:"start_time" time_format:"rfc3339"`
	EndTime   *time.Time `form:"end_time" time_format:"rfc3339"`
	OrderBy   string     `form:"order_by"`
}

// PlanExecutionLogDTO 是用于API响应的计划执行日志结构
type PlanExecutionLogDTO struct {
	ID        uint                   `json:"id"`
	CreatedAt time.Time              `json:"created_at"`
	UpdatedAt time.Time              `json:"updated_at"`
	PlanID    uint                   `json:"plan_id"`
	Status    models.ExecutionStatus `json:"status"`
	StartedAt time.Time              `json:"started_at"`
	EndedAt   time.Time              `json:"ended_at"`
	Error     string                 `json:"error"`
}

// ListPlanExecutionLogResponse 是获取计划执行日志列表的响应结构
type ListPlanExecutionLogResponse struct {
	List       []PlanExecutionLogDTO `json:"list"`
	Pagination PaginationDTO         `json:"pagination"`
}

// NewListPlanExecutionLogResponse 从模型数据创建列表响应 DTO
func NewListPlanExecutionLogResponse(data []models.PlanExecutionLog, total int64, page, pageSize int) *ListPlanExecutionLogResponse {
	dtos := make([]PlanExecutionLogDTO, len(data))
	for i, item := range data {
		dtos[i] = PlanExecutionLogDTO{
			ID:        item.ID,
			CreatedAt: item.CreatedAt,
			UpdatedAt: item.UpdatedAt,
			PlanID:    item.PlanID,
			Status:    item.Status,
			StartedAt: item.StartedAt,
			EndedAt:   item.EndedAt,
			Error:     item.Error,
		}
	}

	return &ListPlanExecutionLogResponse{
		List: dtos,
		Pagination: PaginationDTO{
			Total:    total,
			Page:     page,
			PageSize: pageSize,
		},
	}
}

// --- TaskExecutionLog ---

// ListTaskExecutionLogRequest 定义了获取任务执行日志列表的请求参数
type ListTaskExecutionLogRequest struct {
	Page               int        `form:"page,default=1"`
	PageSize           int        `form:"pageSize,default=10"`
	PlanExecutionLogID *uint      `form:"plan_execution_log_id"`
	TaskID             *int       `form:"task_id"`
	Status             *string    `form:"status"`
	StartTime          *time.Time `form:"start_time" time_format:"rfc3339"`
	EndTime            *time.Time `form:"end_time" time_format:"rfc3339"`
	OrderBy            string     `form:"order_by"`
}

// TaskDTO 是用于API响应的简化版任务结构
type TaskDTO struct {
	ID          uint   `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
}

// TaskExecutionLogDTO 是用于API响应的任务执行日志结构
type TaskExecutionLogDTO struct {
	ID                 uint                   `json:"id"`
	CreatedAt          time.Time              `json:"created_at"`
	UpdatedAt          time.Time              `json:"updated_at"`
	PlanExecutionLogID uint                   `json:"plan_execution_log_id"`
	TaskID             int                    `json:"task_id"`
	Task               TaskDTO                `json:"task"` // 嵌套的任务信息
	Status             models.ExecutionStatus `json:"status"`
	Output             string                 `json:"output"`
	StartedAt          time.Time              `json:"started_at"`
	EndedAt            time.Time              `json:"ended_at"`
}

// ListTaskExecutionLogResponse 是获取任务执行日志列表的响应结构
type ListTaskExecutionLogResponse struct {
	List       []TaskExecutionLogDTO `json:"list"`
	Pagination PaginationDTO         `json:"pagination"`
}

// NewListTaskExecutionLogResponse 从模型数据创建列表响应 DTO
func NewListTaskExecutionLogResponse(data []models.TaskExecutionLog, total int64, page, pageSize int) *ListTaskExecutionLogResponse {
	dtos := make([]TaskExecutionLogDTO, len(data))
	for i, item := range data {
		dtos[i] = TaskExecutionLogDTO{
			ID:                 item.ID,
			CreatedAt:          item.CreatedAt,
			UpdatedAt:          item.UpdatedAt,
			PlanExecutionLogID: item.PlanExecutionLogID,
			TaskID:             item.TaskID,
			Task: TaskDTO{
				ID:          uint(item.Task.ID),
				Name:        item.Task.Name,
				Description: item.Task.Description,
			},
			Status:    item.Status,
			Output:    item.Output,
			StartedAt: item.StartedAt,
			EndedAt:   item.EndedAt,
		}
	}

	return &ListTaskExecutionLogResponse{
		List: dtos,
		Pagination: PaginationDTO{
			Total:    total,
			Page:     page,
			PageSize: pageSize,
		},
	}
}

// --- PendingCollection ---

// ListPendingCollectionRequest 定义了获取待采集请求列表的请求参数
type ListPendingCollectionRequest struct {
	Page      int        `form:"page,default=1"`
	PageSize  int        `form:"pageSize,default=10"`
	DeviceID  *uint      `form:"device_id"`
	Status    *string    `form:"status"`
	StartTime *time.Time `form:"start_time" time_format:"rfc3339"`
	EndTime   *time.Time `form:"end_time" time_format:"rfc3339"`
	OrderBy   string     `form:"order_by"`
}

// PendingCollectionDTO 是用于API响应的待采集请求结构
type PendingCollectionDTO struct {
	CorrelationID   string                         `json:"correlation_id"`
	DeviceID        uint                           `json:"device_id"`
	CommandMetadata models.UintArray               `json:"command_metadata"`
	Status          models.PendingCollectionStatus `json:"status"`
	FulfilledAt     *time.Time                     `json:"fulfilled_at"`
	CreatedAt       time.Time                      `json:"created_at"`
}

// ListPendingCollectionResponse 是获取待采集请求列表的响应结构
type ListPendingCollectionResponse struct {
	List       []PendingCollectionDTO `json:"list"`
	Pagination PaginationDTO          `json:"pagination"`
}

// NewListPendingCollectionResponse 从模型数据创建列表响应 DTO
func NewListPendingCollectionResponse(data []models.PendingCollection, total int64, page, pageSize int) *ListPendingCollectionResponse {
	dtos := make([]PendingCollectionDTO, len(data))
	for i, item := range data {
		dtos[i] = PendingCollectionDTO{
			CorrelationID:   item.CorrelationID,
			DeviceID:        item.DeviceID,
			CommandMetadata: item.CommandMetadata,
			Status:          item.Status,
			FulfilledAt:     item.FulfilledAt,
			CreatedAt:       item.CreatedAt,
		}
	}

	return &ListPendingCollectionResponse{
		List: dtos,
		Pagination: PaginationDTO{
			Total:    total,
			Page:     page,
			PageSize: pageSize,
		},
	}
}