package model

import (
	"time"
	"xps/datamodels"
	"xps/datasource"
	"xps/repositories/model"
	"xps/viewmodels"
)

type ObjectService interface {
	GetList(m map[string]interface{}) ([]viewmodels.ObjectInfo, error)
	GetPage(m map[string]interface{}) (*viewmodels.PageResult, error)
	GetById(modelId, objectId int64) (*viewmodels.ObjectInfo, error)
	Create(d *datamodels.Object) error
	Update(d *datamodels.Object) error
	Delete(m map[string]interface{}) error
	GetObjectDataById(modelId, objectId int64) (*viewmodels.ObjectDataInfo, error)
	CreateObjectData(d *viewmodels.ObjectDataInfo) error
	UpdateObjectData(d *viewmodels.ObjectDataInfo) error
}

type objectService struct {
	objectRepo     *model.ObjectRepo
	objectAttrRepo *model.ObjectAttrRepo
}

func NewObjectService() ObjectService {
	return &objectService{
		objectRepo:     model.NewObjectRepo(datasource.InstanceMaster()),
		objectAttrRepo: model.NewObjectAttrRepo(datasource.InstanceMaster()),
	}
}

func (s *objectService) GetList(m map[string]interface{}) ([]viewmodels.ObjectInfo, error) {
	return s.objectRepo.GetList(m)
}

func (s *objectService) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
	return s.objectRepo.GetPage(m)
}

func (s *objectService) GetById(modelId, objectId int64) (*viewmodels.ObjectInfo, error) {
	return s.objectRepo.GetById(modelId, objectId)
}

func (s *objectService) Create(Object *datamodels.Object) error {
	Object.ObjectId = NewID()
	return s.objectRepo.Create(Object)
}

func (s *objectService) Update(Object *datamodels.Object) error {
	return s.objectRepo.Update(Object)
}

func (s *objectService) Delete(m map[string]interface{}) error {
	modelId  := m["modelId"].(int64)
	objectId := m["objectId"].(int64)
	err := s.objectRepo.Delete(m)
	if err != nil {
		return err
	}
	return s.objectAttrRepo.DeleteByObjectId(modelId, objectId)
}

func (s *objectService) GetObjectDataById(modelId, objectId int64) (*viewmodels.ObjectDataInfo, error) {
	objectInfo, err := s.objectRepo.GetById(modelId, objectId)
	if err != nil {
		return nil, err
	}

	m := make(map[string]interface{}, 0)
	m["modelId"] = modelId
	m["objectId"] = objectId
	m["keywords"] = ""
	attrs, err := s.objectAttrRepo.GetList(m)
	if err != nil {
		return nil, err
	}

	objectDataInfo := &viewmodels.ObjectDataInfo{
		ModelId:     objectInfo.ModelId,
		ObjectId:    objectInfo.ObjectId,
		ObjectType:  objectInfo.ObjectType,
		ObjectTitle: objectInfo.ObjectTitle,
		ObjectCode:  objectInfo.ObjectCode,
		Comment:     objectInfo.Comment,
		IsFixed:     objectInfo.IsFixed,
		CreatedBy:   objectInfo.CreatedBy,
		CreatedAt:   objectInfo.CreatedAt,
		UpdatedAt:   objectInfo.UpdatedAt,
		UpdatedBy:   objectInfo.UpdatedBy,
		DeletedAt:   objectInfo.DeletedAt,
		DeletedBy:   objectInfo.DeletedBy,
		DeletedFlag: 0,
		Attrs:       attrs,
	}

	return objectDataInfo, nil
}

func (s *objectService) CreateObjectData(o *viewmodels.ObjectDataInfo) error {
	modelId   := o.ModelId
	objectId  := NewID()
	createdBy := o.CreatedBy
	object := &datamodels.Object{
		ModelId:     modelId,
		ObjectId:    objectId,
		ObjectType:  o.ObjectType,
		ObjectTitle: o.ObjectTitle,
		ObjectCode:  o.ObjectCode,
		Comment:     o.Comment,
		IsFixed:     0,
		CreatedBy:   createdBy,
		CreatedAt:   time.Now(),
	}

	err := s.objectRepo.Create(object)
	if err != nil {
		return err
	}

	for _, a := range o.Attrs {
		newId := NewID()
		objectAttr := &datamodels.ObjectAttr{
			ModelId:      modelId,
			ObjectId:     objectId,
			AttrId:       newId,
			AttrTitle:    a.AttrTitle,
			AttrCode:     a.AttrCode,
			AttrType:     a.AttrType,
			AttrLength:   a.AttrLength,
			AttrDecimals: a.AttrDecimals,
			Comment:      a.Comment,
			IsFixed:      a.IsFixed,
			IsNotNull:    a.IsNotNull,
			IsPKey:       a.IsPKey,
			CreatedAt:    time.Now(),
			CreatedBy:    createdBy,
		}

		err = s.objectAttrRepo.Create(objectAttr)
		if err != nil {
			return err
		}
	}

	return nil
}

func (s *objectService) UpdateObjectData(o *viewmodels.ObjectDataInfo) error {
	modelId   := o.ModelId
	objectId  := o.ObjectId
	updatedBy := o.UpdatedBy
	object := &datamodels.Object{
		ModelId:     modelId,
		ObjectId:    objectId,
		ObjectType:  o.ObjectType,
		ObjectTitle: o.ObjectTitle,
		ObjectCode:  o.ObjectCode,
		Comment:     o.Comment,
		IsFixed:     0,
		UpdatedBy:   updatedBy,
	}

	err := s.objectRepo.Update(object)
	if err != nil {
		return err
	}

	err = s.objectAttrRepo.DeleteByObjectId(modelId, objectId)
	if err != nil {
		return err
	}

	for _, a := range o.Attrs {
		newId := NewID()
		objectAttr := &datamodels.ObjectAttr{
			ModelId:      modelId,
			ObjectId:     objectId,
			AttrId:       newId,
			AttrTitle:    a.AttrTitle,
			AttrCode:     a.AttrCode,
			AttrType:     a.AttrType,
			AttrLength:   a.AttrLength,
			AttrDecimals: a.AttrDecimals,
			Comment:      a.Comment,
			IsFixed:      a.IsFixed,
			IsNotNull:    a.IsNotNull,
			IsPKey:       a.IsPKey,
			CreatedBy:    updatedBy,
		}

		err = s.objectAttrRepo.Create(objectAttr)
		if err != nil {
			return err
		}
	}

	return nil
}