package service

import (
	"errors"
	"github.com/jinzhu/copier"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/entity"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/vo/request"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/vo/response"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/common/client"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/pkg/beagle/jsontime"
	"gitlab.wodcloud.com/smart-operation/so-operation-api/src/pkg/beagle/resp"
)

type AlertClassSvc struct {
	User entity.SystemUserInfo
}

func (m *AlertClassSvc) Add(req request.AddAlertClass) (err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return err
	}
	now := jsontime.Now()
	data := entity.AlertClass{
		CreatedBy: "",
		CreatedAt: now,
		UpdatedBy: "",
		UpdatedAt: now,
	}
	_ = copier.Copy(&data, &req)

	max, err := m.SortOrderMax(data.ParentId)
	if err != nil {
		return
	}
	data.SortOrder = max + 1
	_, err = db.NewSession().Insert(&data)
	return nil
}

func (m *AlertClassSvc) Update(req request.UpdateAlertClass) error {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return err
	}
	now := jsontime.Now()
	data := entity.AlertClass{
		UpdatedBy: "",
		UpdatedAt: now,
	}
	_ = copier.Copy(&data, &req)
	_, err = db.NewSession().Cols("class_name", "updated_by", "updated_at").ID(data.ClassId).Update(&data)
	if err != nil {
		return err
	}
	return nil
}

func (m *AlertClassSvc) Move(req request.MoveAlertClass) (err error) {
	db, err := client.GetDbClient()
	if err != nil {
		err = resp.DbConnectError.WithError(err)
		return err
	}
	now := jsontime.Now()
	data := entity.AlertClass{
		UpdatedBy: "",
		UpdatedAt: now,
	}
	_ = copier.Copy(&data, &req)
	var list []entity.AlertClass
	_, err = db.NewSession().Where("id = ?", req.ClassId).Get(&data)
	err = db.NewSession().Where("parent_id = ?", data.ParentId).OrderBy("sort_order asc").Find(&list)
	var previousIndex int
	var nextIndex int
	for i := 0; i < len(list); i++ {
		if list[i].ClassId == req.ClassId {
			previousIndex = i - 1
			nextIndex = i + 1
			break
		}
	}

	var (
		mover entity.AlertClass
		moved entity.AlertClass
	)

	switch req.Direction {
	case "up":
		if previousIndex < 0 {
			err = errors.New("top data cannot be moved")
			return
		}
		list[previousIndex].SortOrder, list[previousIndex+1].SortOrder = list[previousIndex+1].SortOrder, list[previousIndex].SortOrder
		mover, moved = list[previousIndex+1], list[previousIndex]

	case "down":
		if nextIndex > len(list)-1 {
			err = errors.New("bottom data cannot be moved")
			return
		}

		list[nextIndex-1].SortOrder, list[nextIndex].SortOrder = list[nextIndex].SortOrder, list[nextIndex-1].SortOrder
		mover, moved = list[nextIndex-1], list[nextIndex]
	}
	mover.UpdatedBy, moved.UpdatedBy = "", ""
	mover.UpdatedAt, moved.UpdatedAt = now, now

	session := db.NewSession()
	defer session.Close()
	err = session.Begin()
	_, err = session.Cols("sort_order", "updated_by", "updated_at").ID(mover.ClassId).Update(&mover)
	if err != nil {
		err = session.Rollback()
		return
	}
	_, err = session.Cols("sort_order", "updated_by", "updated_at").ID(moved.ClassId).Update(&moved)
	if err != nil {
		err = session.Rollback()
		return
	}
	err = session.Commit()
	if err != nil {
		return
	}
	return nil
}

func (m *AlertClassSvc) GetDataById(req request.DetailAlertClass) (resp response.AlertClassItem, err error) {
	db, err := client.GetDbClient()
	if err != nil {
		return
	}
	_, err = db.NewSession().Table(resp.TableName()).ID(req.ClassId).Get(&resp)
	return
}

func (m *AlertClassSvc) List(req request.ListAlertClass) (resp response.AlertClassList, err error) {
	db, err := client.GetDbClient()
	if err != nil {
		return
	}
	session := db.NewSession()
	defer session.Close()
	if req.ClassId != 0 {
		session.Where("class_id = ?", req.ClassId)
	}
	if req.ClassName != "" {
		session.Where("class_name LIKE ?", "%"+req.ClassName+"%")
	}
	resp.TotalCount, err = session.Limit(req.GetPageSize(), (req.GetPage()-1)*req.GetPageSize()).
		OrderBy("sort_order").FindAndCount(&resp.List)
	return
}

func (m *AlertClassSvc) SortOrderMax(parentId int) (max int, err error) {
	db, err := client.GetDbClient()
	if err != nil {
		return
	}
	_, err = db.NewSession().Table(new(entity.AlertClass)).
		Select("max(sort_order)").
		Where("parent_id = ?", parentId).Get(&max)
	return
}

func (m *AlertClassSvc) DeleteDataById(req request.DeleteAlertClass) (err error) {
	db, err := client.GetDbClient()
	if err != nil {
		return
	}
	_, err = db.NewSession().ID(req.ClassId).Delete(&entity.AlertClass{})
	return
}