package db

import (
	"context"
	"time"

	"lmika.dev/lmika/weiro/models"
	"lmika.dev/lmika/weiro/providers/db/gen/sqlgen"
)

func (db *Provider) SelectUploadByID(ctx context.Context, id int64) (models.Upload, error) {
	row, err := db.queries.SelectUploadByID(ctx, id)
	if err != nil {
		return models.Upload{}, err
	}

	return dbUploadToUpload(row), nil
}

func (db *Provider) SelectUploadsOfSite(ctx context.Context, siteID int64) ([]models.Upload, error) {
	rows, err := db.queries.SelectUploadsOfSite(ctx, siteID)
	if err != nil {
		return nil, err
	}

	uploads := make([]models.Upload, len(rows))
	for i, row := range rows {
		uploads[i] = dbUploadToUpload(row)
	}
	return uploads, nil
}

func (db *Provider) SelectUploadBySiteIDAndSlug(ctx context.Context, siteID int64, slug string) (models.Upload, error) {
	row, err := db.queries.SelectUploadBySiteIDAndSlug(ctx, sqlgen.SelectUploadBySiteIDAndSlugParams{
		SiteID: siteID,
		Slug:   slug,
	})
	if err != nil {
		return models.Upload{}, err
	}

	return dbUploadToUpload(row), nil
}

func (db *Provider) SaveUpload(ctx context.Context, upload *models.Upload) error {
	if upload.ID == 0 {
		if err := db.queries.InsertUpload(ctx, sqlgen.InsertUploadParams{
			SiteID:    upload.SiteID,
			Guid:      upload.GUID,
			MimeType:  upload.MIMEType,
			Filename:  upload.Filename,
			FileSize:  upload.FileSize,
			Slug:      upload.Slug,
			Alt:       upload.Alt,
			CreatedAt: upload.CreatedAt.Unix(),
		}); err != nil {
			return err
		}
		return nil
	}

	return db.queries.UpdateUpload(ctx, sqlgen.UpdateUploadParams{
		Alt: upload.Alt,
		ID:  upload.ID,
	})
}

func (db *Provider) DeleteUpload(ctx context.Context, id int64) error {
	return db.queries.DeleteUpload(ctx, id)
}

func (db *Provider) SelectPendingUploadByGUID(ctx context.Context, guid string) (models.PendingUpload, error) {
	row, err := db.queries.SelectPendingUploadByGUID(ctx, guid)
	if err != nil {
		return models.PendingUpload{}, err
	}

	return dbPendingUploadToPendingUpload(row), nil
}

func (db *Provider) SavePendingUpload(ctx context.Context, pending *models.PendingUpload) error {
	_, err := db.queries.InsertPendingUpload(ctx, sqlgen.InsertPendingUploadParams{
		SiteID:          pending.SiteID,
		Guid:            pending.GUID,
		UserID:          pending.UserID,
		Filename:        pending.Filename,
		FileSize:        pending.FileSize,
		MimeType:        pending.MIMEType,
		UploadStartedAt: pending.UploadStarted.Unix(),
	})
	return err
}

func (db *Provider) DeletePendingUpload(ctx context.Context, guid string) error {
	return db.queries.DeletePendingUpload(ctx, guid)
}

func dbUploadToUpload(row sqlgen.Upload) models.Upload {
	return models.Upload{
		ID:        row.ID,
		SiteID:    row.SiteID,
		GUID:      row.Guid,
		MIMEType:  row.MimeType,
		FileSize:  row.FileSize,
		Filename:  row.Filename,
		Slug:      row.Slug,
		Alt:       row.Alt,
		CreatedAt: time.Unix(row.CreatedAt, 0).UTC(),
	}
}

func dbPendingUploadToPendingUpload(row sqlgen.PendingUpload) models.PendingUpload {
	return models.PendingUpload{
		GUID:          row.Guid,
		SiteID:        row.SiteID,
		UserID:        row.UserID,
		FileSize:      row.FileSize,
		Filename:      row.Filename,
		MIMEType:      row.MimeType,
		UploadStarted: time.Unix(row.UploadStartedAt, 0),
	}
}