package service

import (
	"SciencesServer/app/api/admin/model"
	"SciencesServer/app/basic/controller"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/session"
	"errors"
)

type Innovate struct {
	*session.Admin
}

type InnovateHandle func(admin *session.Admin) *Innovate

type (
	// InnovateInfo 服务信息
	InnovateInfo struct {
		ID string `json:"id"`
		*model.ServiceInnovateInfo
		Area string `json:"area"`
	}
	// InnovateDetail 服务详细信息
	InnovateDetail struct {
		ID string `json:"id"`
		*model2.ServiceInnovate
		KindID string   `json:"kind_id"`
		Tags   []string `json:"tags"`
	}
	// InnovateParams 服务参数信息
	InnovateParams struct {
		ID, KindID     uint64
		Title, Content string
		Tags           []string
		Sort           int
	}
	// InnovateKindInfo 服务分类信息
	InnovateKindInfo struct {
		ID string `json:"id"`
		*model.ServiceInnovateKindInfo
		Area string `json:"area"`
	}
	// InnovateKindSelectInfo 服务分类筛选信息
	InnovateKindSelectInfo struct {
		ID    string `json:"id"`
		Title string `json:"title"`
	}
	// InnovateKindParams 服务分类参数信息
	InnovateKindParams struct {
		ID    uint64
		Title string
		Sort  int
	}
)

// Instance 首页信息
func (c *Innovate) Instance(tenantID uint64, title string, kindID uint64, page, pageSize int) (*controller.ReturnPages, error) {
	mServiceInnovate := model.NewServiceInnovate()

	where := make([]*model2.ModelWhere, 0)

	if c.TenantID > 0 {
		where = append(where, model2.NewWhere("i.tenant_id", c.TenantID))
	}
	if tenantID > 0 {
		where = append(where, model2.NewWhere("i.tenant_id", tenantID))
	}
	if title != "" {
		where = append(where, model2.NewWhereLike("i.title", title))
	}
	if kindID > 0 {
		where = append(where, model2.NewWhere("i.kind_id", kindID))
	}
	var count int64

	out, err := mServiceInnovate.Innovate(page, pageSize, &count, where...)

	if err != nil {
		return nil, err
	}
	list := make([]*InnovateInfo, 0)

	for _, v := range out {
		list = append(list, &InnovateInfo{
			ID: v.GetEncodeID(), ServiceInnovateInfo: v, Area: v.Area.FormatBasic(),
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

// Detail 详细信息
func (c *Innovate) Detail(id uint64) (*InnovateDetail, error) {
	mServiceInnovate := model.NewServiceInnovate()
	mServiceInnovate.ID = id

	isExist, err := model2.First(mServiceInnovate.ServiceInnovate)

	if err != nil {
		return nil, err
	} else if !isExist {
		return nil, errors.New("操作错误，服务信息不存在或已被删除")
	}
	return &InnovateDetail{
		ID:              mServiceInnovate.GetEncodeID(),
		ServiceInnovate: mServiceInnovate.ServiceInnovate,
		KindID:          (&model2.Model{ID: mServiceInnovate.KindID}).GetEncodeID(),
		Tags:            mServiceInnovate.GetTagAttribute(),
	}, nil
}

// Form 数据操作
func (c *Innovate) Form(params *InnovateParams) error {
	mServiceInnovate := model.NewServiceInnovate()

	if params.ID > 0 {
		mServiceInnovate.ID = params.ID

		isExist, err := model2.FirstField(mServiceInnovate.ServiceInnovate, []string{"id", "tenant_id", "created_at"})

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，服务信息不存在或已被删除")
		}
		if c.TenantID > 0 && c.TenantID != mServiceInnovate.TenantID {
			return errors.New("操作错误，无权限操作")
		}
	}
	mServiceInnovate.KindID = params.KindID
	mServiceInnovate.Title = params.Title
	mServiceInnovate.Content = params.Content
	mServiceInnovate.SetTagAttribute(params.Tags)
	mServiceInnovate.Sort = params.Sort

	if mServiceInnovate.ID > 0 {
		return model2.Updates(mServiceInnovate.ServiceInnovate, mServiceInnovate.ServiceInnovate)
	}
	mServiceInnovate.TenantID = c.TenantID
	return model2.Create(mServiceInnovate.ServiceInnovate)
}

// Delete 删除操作
func (c *Innovate) Delete(id uint64) error {
	mServiceInnovate := model.NewServiceInnovate()

	mServiceInnovate.ID = id

	isExist, err := model2.FirstField(mServiceInnovate.ServiceInnovate, []string{"id", "tenant_id"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，服务信息不存在或已被删除")
	}
	if c.TenantID > 0 && c.TenantID != mServiceInnovate.TenantID {
		return errors.New("操作错误，无权限操作")
	}
	return model2.Delete(mServiceInnovate.ServiceInnovate)
}

// Kind 分类信息
func (c *Innovate) Kind(tenantID uint64, title string, page, pageSize int) (*controller.ReturnPages, error) {
	mServiceInnovateKind := model.NewServiceInnovateKind()

	var count int64

	where := make([]*model2.ModelWhere, 0)

	if c.TenantID > 0 {
		where = append(where, model2.NewWhere("k.tenant_id", c.TenantID))
	}
	if tenantID > 0 {
		where = append(where, model2.NewWhere("k.tenant_id", tenantID))
	}
	if title != "" {
		where = append(where, model2.NewWhereLike("k.title", title))
	}

	out, err := mServiceInnovateKind.Kind(page, pageSize, &count, where...)

	if err != nil {
		return nil, err
	}
	list := make([]*InnovateKindInfo, 0)

	for _, v := range out {
		list = append(list, &InnovateKindInfo{
			ID: v.GetEncodeID(), ServiceInnovateKindInfo: v, Area: v.FormatBasic(),
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

// KindSelect 分类筛选信息
func (c *Innovate) KindSelect() ([]*InnovateKindSelectInfo, error) {
	mServiceInnovateKind := model.NewServiceInnovateKind()

	out := make([]*model2.ServiceInnovateKind, 0)

	where := []*model2.ModelWhereOrder{&model2.ModelWhereOrder{
		Where: model2.NewWhere("tenant_id", c.TenantID),
		Order: model2.NewOrder("sort", model2.OrderModeToAsc),
	}, &model2.ModelWhereOrder{
		Order: model2.NewOrder("id", model2.OrderModeToDesc),
	}}
	if err := model2.ScanFields(mServiceInnovateKind.ServiceInnovateKind, &out, []string{"id", "title"}, where...); err != nil {
		return nil, err
	}
	list := make([]*InnovateKindSelectInfo, 0)

	for _, v := range out {
		list = append(list, &InnovateKindSelectInfo{
			ID: v.GetEncodeID(), Title: v.Title,
		})
	}
	return list, nil
}

// KindForm 分类数据处理
func (c *Innovate) KindForm(params *InnovateKindParams) error {
	mServiceInnovateKind := model.NewServiceInnovateKind()

	if params.ID > 0 {
		mServiceInnovateKind.ID = params.ID

		isExist, err := model2.FirstField(mServiceInnovateKind.ServiceInnovateKind, []string{"id", "tenant_id", "created_at"})

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，服务分类信息不存在或已被删除")
		}
		if c.TenantID > 0 && c.TenantID != mServiceInnovateKind.TenantID {
			return errors.New("操作错误，无权限操作")
		}
	}
	mServiceInnovateKind.Title = params.Title
	mServiceInnovateKind.Sort = params.Sort

	if mServiceInnovateKind.ID > 0 {
		return model2.Updates(mServiceInnovateKind.ServiceInnovateKind, mServiceInnovateKind.ServiceInnovateKind)
	}
	mServiceInnovateKind.TenantID = c.TenantID
	return model2.Create(mServiceInnovateKind.ServiceInnovateKind)
}

// KindDelete 分类数据删除
func (c *Innovate) KindDelete(id uint64) error {
	mServiceInnovateKind := model.NewServiceInnovateKind()

	mServiceInnovateKind.ID = id

	isExist, err := model2.FirstField(mServiceInnovateKind.ServiceInnovateKind, []string{"id", "tenant_id"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，服务分类信息不存在或已被删除")
	}
	if c.TenantID > 0 && c.TenantID != mServiceInnovateKind.TenantID {
		return errors.New("操作错误，无权限操作")
	}
	return model2.Delete(mServiceInnovateKind.ServiceInnovateKind)
}

func NewInnovate() InnovateHandle {
	return func(admin *session.Admin) *Innovate {
		return &Innovate{admin}
	}
}