package panel

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/han-joker/moo-layout/api/moo/dbm"
	"github.com/han-joker/moo-layout/api/moo/logm"
	"github.com/han-joker/moo-layout/api/panel/models"
	"github.com/han-joker/moo-layout/api/tables"
	"net/http"
	"strconv"
	"strings"
	"time"
)

const (
	contentsLimit = 10
)

func ContentPost(c *gin.Context) {
	req := models.ContentReq{}
	if err := c.ShouldBind(&req); err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	row := &tables.Content{
		Subject:    req.Subject,
		Content:    req.Content,
		Referer:    req.Referer,
		CategoryID: req.CategoryID,
		Cover:      req.Cover,
		Status:     req.Status,
		Sorter: req.Sorter,
		UserID:     1,
	}
	if row.Status == tables.ContentStatusPublish {
		row.PublishTime = time.Now()
	}
	for _, p := range req.Promotes {
		row.Promotes |= p
	}

	if err := dbm.Get().Create(&row).Error; err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"error":  nil,
		"row": row,
	})
}

func ContentPut(c *gin.Context) {
	id, err := strconv.Atoi(c.Query("id"))
	if err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	row := tables.Content{}
	if err := dbm.Get().Where("id=?", id).First(&row).Error; err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	req := models.ContentReq{}
	if err := c.ShouldBind(&req); err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}
	row.Subject = req.Subject
	row.Content = req.Content
	row.Referer = req.Referer
	row.CategoryID = req.CategoryID
	row.Cover = req.Cover
	row.Status = req.Status
	row.Sorter = req.Sorter
	if row.Status == tables.ContentStatusPublish {
		row.PublishTime = time.Now()
	}
	row.Promotes = 0
	for _, p := range req.Promotes {
		row.Promotes |= p
	}

	if err := dbm.Get().Save(&row).Error; err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"error":  nil,
		"row": row,
	})
}

func ContentGets(c *gin.Context) {
	query := models.ContentsQuery{}
	if err := c.ShouldBind(&query); err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	rows := make([]tables.Content, 0)
	db := dbm.Get().Model(&tables.Content{})

	if len(query.Filters.IDs) > 0 {
		db.Where("id IN ?", query.Filters.IDs)
	}
	if query.Filters.CategoryID != 0 {
		db.Where("category_id=?", query.Filters.CategoryID)
	}
	if len(query.Filters.Status) > 0 {
		db.Where("status IN ?", query.Filters.Status)
	}
	if len(query.Filters.Promotes) > 0 {
		pc := make([]string, len(query.Filters.Promotes))
		pv := make([]interface{}, len(query.Filters.Promotes))
		for i, p := range query.Filters.Promotes {
			pc[i] = "promotes & ? > 0"
			pv[i] = p
		}
		db.Where(strings.Join(pc, " OR "), pv...)
	}

	if query.Sorter.Field != "" && query.Sorter.Order != "" {
		db.Order(fmt.Sprintf("%s %s", query.Sorter.Field, models.OrderText[query.Sorter.Order])).
			Order("updated_at desc")
	} else {
		db.Order("updated_at desc")
	}

	db.Count(&query.Pagination.Total)

	if query.Pagination.PageSize > 0 {
		offset := (query.Pagination.Current - 1) * query.Pagination.PageSize
		db.Limit(query.Pagination.PageSize).Offset(offset)
	}

	db.Find(&rows)

	c.JSON(http.StatusOK, gin.H{
		"error":      nil,
		"rows":       rows,
		"pagination": query.Pagination,
		"filters":    query.Filters,
		"sorter":     query.Sorter,
	})
}

func ContentGet(c *gin.Context) {

	id, err := strconv.Atoi(c.Query("id"))
	if err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	row := tables.Content{}
	if err := dbm.Get().Where("id=?", id).First(&row).Error; err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"error": nil,
		"row":   row,
	})
}

func ContentDelete(c *gin.Context) {
	id, err := strconv.Atoi(c.Query("id"))
	if err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	row := tables.Content{}
	if err := dbm.Get().Where("id=?", id).First(&row).Error; err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	if err := dbm.Get().Delete(&row).Error; err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"error":   nil,
		"row": row,
	})
}

func ContentCount(c *gin.Context) {

	query := models.ContentsQuery{}
	if err := c.ShouldBind(&query); err != nil {
	}

	db := dbm.Get().Model(&tables.Content{})

	if query.Filters.CategoryID != 0 {
		db.Where("category_id=?", query.Filters.CategoryID)
	}
	if len(query.Filters.Status) != 0 {
		db.Where("status IN ?", query.Filters.Status)
	}
	count := int64(0)
	if err := db.Debug().Count(&count).Error; err != nil {
		logm.Get().Info(err.Error())
		c.JSON(http.StatusOK, gin.H{
			"error": err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"error":   nil,
		"count": count,
	})

}