package model

import (
	"encoding/json"
	"github.com/loveuer/nfflow/internal/interfaces"
	"github.com/loveuer/nfflow/internal/sqlType"
)

type InputType int64

const (
	InputTypeES InputType = iota + 1
	InputTypePG
	InputTypeMQ
)

type OutputType int64

const (
	OutputTypeES OutputType = iota + 1
	OutputTypeFile
	OutputTypeMQ
)

type PipeType int64

func (p PipeType) Value() int64 { return int64(p) }

func (p PipeType) Code() string {
	switch p {
	case PipeTypeLoadashMap:
		return "pipe_map"
	default:
		return "unknown"
	}
}

func (p PipeType) Label() string {
	switch p {
	case PipeTypeLoadashMap:
		return "Map"
	default:
		return "未知"
	}
}

func (p PipeType) MarshalJSON() ([]byte, error) {
	return json.Marshal(map[string]any{"value": p.Value(), "code": p.Code(), "label": p.Label()})
}

func (p PipeType) All() []interfaces.Enum {
	return []interfaces.Enum{PipeTypeLoadashMap}
}

const (
	PipeTypeLoadashMap PipeType = iota + 1
)

var _ interfaces.Enum = (*PipeType)(nil)

type TaskStatus int64

func (t TaskStatus) MarshalJSON() ([]byte, error) {
	return json.Marshal(map[string]any{
		"value": t.Value(),
		"code":  t.Code(),
		"label": t.Label(),
	})
}

func (t TaskStatus) All() []interfaces.Enum {
	return []interfaces.Enum{
		TaskStatusNotReady,
		TaskStatusReady,
		TaskStatusRunning,
		TaskStatusSucceed,
		TaskStatusFailed,
	}
}

var _ interfaces.Enum = (*TaskStatus)(nil)

const (
	TaskStatusNotReady TaskStatus = iota
	TaskStatusReady
	TaskStatusRunning
	TaskStatusSucceed
	TaskStatusFailed
)

func (t TaskStatus) Value() int64 {
	return int64(t)
}

func (t TaskStatus) Code() string {
	switch t {
	case TaskStatusNotReady:
		return "not_ready"
	case TaskStatusReady:
		return "ready"
	case TaskStatusRunning:
		return "running"
	case TaskStatusSucceed:
		return "succeed"
	case TaskStatusFailed:
		return "failed"
	default:
		return "unknown"
	}
}

func (t TaskStatus) Label() string {
	switch t {
	case TaskStatusNotReady:
		return "未完善"
	case TaskStatusReady:
		return "等待执行"
	case TaskStatusRunning:
		return "执行中"
	case TaskStatusSucceed:
		return "执行成功"
	case TaskStatusFailed:
		return "执行失败"
	default:
		return "未知"
	}
}

type TaskRunType int64

const (
	TaskRunTypeOnce TaskRunType = iota
	TaskRunTypeTiming
	TaskRunTypeCron
)

func (t TaskRunType) Value() int64 { return int64(t) }

func (t TaskRunType) Code() string {
	switch t {
	case TaskRunTypeOnce:
		return "once"
	case TaskRunTypeTiming:
		return "timing"
	case TaskRunTypeCron:
		return "cron"
	default:
		return "unknown"
	}
}

func (t TaskRunType) Label() string {
	switch t {
	case TaskRunTypeOnce:
		return "手动执行"
	case TaskRunTypeTiming:
		return "定时执行"
	case TaskRunTypeCron:
		return "周期执行"
	default:
		return "未知"
	}
}

func (t TaskRunType) MarshalJSON() ([]byte, error) {
	return json.Marshal(map[string]any{"code": t.Code(), "value": t.Value(), "label": t.Label()})
}

func (t TaskRunType) All() []interfaces.Enum {
	return []interfaces.Enum{TaskRunTypeOnce, TaskRunTypeTiming, TaskRunTypeCron}
}

var _ interfaces.Enum = TaskRunType(0)

type Task struct {
	Id        uint64 `json:"id" gorm:"primaryKey;column:id"`
	CreatedAt int64  `json:"created_at" gorm:"column:created_at;autoCreateTime:milli"`
	UpdatedAt int64  `json:"updated_at" gorm:"column:updated_at;autoUpdateTime:milli"`
	DeletedAt int64  `json:"deleted_at" gorm:"index;column:deleted_at;default:0"`

	TaskName    string      `json:"task_name" gorm:"column:task_name;type:varchar(256)"`
	TaskRunType TaskRunType `json:"task_run_type" gorm:"column:task_run_type;type:varchar(16);default:0"` // cron: C-"cron syntax", "once", timestamp: T-1234567890123 毫秒时间戳
	TaskRunAt   int64       `json:"task_run_at" gorm:"column:task_run_at"`
	TaskCron    string      `json:"task_cron" gorm:"column:task_cron;type:varchar(32)"`
	TaskTimeout int         `json:"task_timeout" gorm:"column:task_timeout"`
	TaskStatus  TaskStatus  `json:"task_status" gorm:"column:task_status"`
	TaskLog     string      `json:"task_log" gorm:"task_log"`
}

type TaskInput struct {
	Id       uint64           `json:"id" gorm:"primaryKey;column:id"`
	TaskId   uint64           `json:"task_id" gorm:"column:task_id"`
	Type     InputType        `json:"type" gorm:"column:type"`
	Config   sqlType.JSONB    `json:"config" gorm:"config"`
	Instance interfaces.Input `json:"instance" gorm:"-"`
}

type TaskOutput struct {
	Id       uint64            `json:"id" gorm:"primaryKey;column:id"`
	TaskId   uint64            `json:"task_id" gorm:"column:task_id"`
	Type     OutputType        `json:"type" gorm:"column:type"`
	Config   sqlType.JSONB     `json:"config" gorm:"config"`
	Instance interfaces.Output `json:"instance" gorm:"-"`
}

type TaskPipe struct {
	Id       uint64          `json:"id" gorm:"primaryKey;column:id"`
	TaskId   uint64          `json:"task_id" gorm:"column:task_id"`
	Sort     int             `json:"sort" gorm:"column:sort"`
	Type     PipeType        `json:"type" gorm:"column:type"`
	Config   sqlType.JSONB   `json:"config" gorm:"config"`
	Instance interfaces.Pipe `json:"instance" gorm:"-"`
}