package models

import (
	"context"

	"quyun/app/requests"
	"quyun/database/schemas/public/model"
	"quyun/database/schemas/public/table"

	. "github.com/go-jet/jet/v2/postgres"
	"github.com/samber/lo"
	"github.com/sirupsen/logrus"
)

type MediaType string

const (
	MediaTypeUnknown  MediaType = "unknown"
	MediaTypeArchive  MediaType = "archive"
	MediaTypeImage    MediaType = "image"
	MediaTypeVideo    MediaType = "video"
	MediaTypeDocument MediaType = "document"
	MediaTypeAudio    MediaType = "audio"
	MediaTypePDF      MediaType = "pdf"
)

type MediaItem struct {
	ID           int64     `json:"id"`
	Name         string    `json:"name"`
	UploadTime   string    `json:"upload_time"`
	FileSize     int64     `json:"file_size"`
	MimeType     string    `json:"media_type"`
	FileType     MediaType `json:"file_type"`
	ThumbnailUrl string    `json:"thumbnail_url"`
}

// @provider
type mediasModel struct {
	log *logrus.Entry `inject:"false"`
}

func (m *mediasModel) Prepare() error {
	m.log = logrus.WithField("module", "mediasModel")
	return nil
}

// countByCond
func (m *mediasModel) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
	var cnt struct {
		Cnt int64
	}

	tbl := table.Medias
	stmt := SELECT(COUNT(tbl.ID).AS("cnt")).FROM(tbl).WHERE(expr)
	m.log.Infof("sql: %s", stmt.DebugSql())

	err := stmt.QueryContext(ctx, db, &cnt)
	if err != nil {
		m.log.Errorf("error counting media items: %v", err)
		return 0, err
	}

	return cnt.Cnt, nil
}

func (m *mediasModel) List(ctx context.Context, pagination *requests.Pagination) (*requests.Pager, error) {
	limit := pagination.Limit
	offset := pagination.Offset()

	tbl := table.Medias
	stmt := tbl.
		SELECT(tbl.AllColumns).
		ORDER_BY(tbl.ID.DESC()).
		LIMIT(limit).
		OFFSET(offset)
	m.log.Infof("sql: %s", stmt.DebugSql())

	var medias []model.Medias
	err := stmt.QueryContext(ctx, db, &medias)
	if err != nil {
		m.log.Errorf("error querying media items: %v", err)
		return nil, err
	}

	count, err := m.countByCondition(ctx, Bool(true))
	if err != nil {
		m.log.Errorf("error getting media count: %v", err)
		return nil, err
	}

	// Convert model.Medias to MediaItem
	mediaItems := lo.Map(medias, func(media model.Medias, _ int) MediaItem {
		return MediaItem{
			ID:           media.ID,
			Name:         media.Name,
			UploadTime:   media.CreatedAt.Format("2006-01-02 15:04:05"),
			FileSize:     media.Size,
			MimeType:     media.MimeType,
			FileType:     m.ConvertFileTypeByMimeType(media.MimeType),
			ThumbnailUrl: "",
		}
	})

	return &requests.Pager{
		Items:      mediaItems,
		Total:      count,
		Pagination: *pagination,
	}, nil
}

func (m *mediasModel) Create(ctx context.Context, model *model.Medias) error {
	stmt := table.Medias.INSERT(table.Medias.MutableColumns).MODEL(model)
	m.log.Infof("sql: %s", stmt.DebugSql())

	if _, err := stmt.ExecContext(ctx, db); err != nil {
		m.log.Errorf("error creating media item: %v", err)
		return err
	}

	m.log.Infof("media item created successfully")
	return nil
}

func (m *mediasModel) ConvertFileTypeByMimeType(mimeType string) MediaType {
	switch mimeType {
	case "image/jpeg":
	case "image/jpg":
	case "image/png":
		return MediaTypeImage
	case "video/mp4":
		return MediaTypeVideo
	case "audio/mpeg":
		return MediaTypeAudio
	case "application/pdf":
		return MediaTypePDF
	case "application/msword":
	case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
	case "application/vnd.ms-excel":
	case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
	case "application/vnd.ms-powerpoint":
	case "application/vnd.openxmlformats-officedocument.presentationml.presentation":
		return MediaTypeDocument
	case "application/rar":
	case "application/x-rar-compressed":
	case "application/x-zip-compressed":
	case "application/x-zip":
	case "application/zip":
	case "application/x-7z-compressed":
		return MediaTypeArchive
	}
	return MediaTypeUnknown
}