package com.persagy.labsl.services

import com.persagy.database.SFilter
import com.persagy.labsl.models.entities.tpt.Relation
import com.persagy.mybatis.SMybatisDao
import com.persagy.service.SObjectService
import com.persagy.service.models.enums.SResponseType
import com.persagy.service.models.requests.SCreateRequest
import com.persagy.service.models.responses.SBaseResponse
import com.persagy.service.models.responses.SCreateResponse
import org.springframework.web.bind.annotation.RequestBody
import java.util.*

/**
 * 管线对象
 *
 * @author wx  <zhangweixin@sagacloud.com>
 */
object RelationService : SObjectService<Relation>(SMybatisDao(
    Relation::class.java)){
    /**
     * 创建之前的操作
     *
     * @param entity    管线对象
     * @return 是否处理
     */
    override fun onCreateBefore(entity: Relation): Boolean {
        /** id 赋值 */
        entity.id = UUID.randomUUID().toString().replace("-", "")
        return super.onCreateBefore(entity)
    } //


    /**
     * 创建管线对象
     *
     * @param request   创建管线对象列表
     * @return 返回结果
     */
    fun creates(request: SCreateRequest<Relation>): SCreateResponse<Relation> {
        /** 返回结果对象 */
        val sCreateResponse = SCreateResponse<Relation>()
        /** 返回结果中的状态 */
        sCreateResponse.result = SResponseType.failure
        return try {

            /** 列表不可以为空 */
            if (!request.content.isNullOrEmpty()) {
                /** 遍历管线列表 */
                for (relation in request.content) {
                    /** 判断必传字段不可以为空 */
                    if (relation.id.isNullOrEmpty() || relation.graphId.isNullOrEmpty() || relation.name.isNullOrEmpty()) {
                        sCreateResponse.message = "注意必填字段不可以为空如 id、graphId、name"
                        return sCreateResponse
                    }
                    /** 查询 id 和 graphId 是否存在，是否可以定位一个系统图 */
                    val graphList =
                        GraphService.select(SFilter.eq("id", relation.id!!), SFilter.eq("graphId", relation.graphId!!))
                            .exec()
                    /** 图 id 和 graphId 不存在*/
                    if (graphList.size == 0) {
                        sCreateResponse.message = "请检查 id 和 graphId 是否为已有系统图中的 id"
                        return sCreateResponse
                    }
                }

                /** 遍历管线列表 */
                for (relation in request.content) {
                    /** 判断标记id是否没有，为空赋值 */
                    if (relation.relationId.isNullOrEmpty()) {
                        relation.relationId = UUID.randomUUID().toString().replace("-", "")
                    }

                    /** 插入数据 */
                    insert(relation)
                }
                /** 对象列表 */
                sCreateResponse.entityList = request.content
                /** 状态 */
                sCreateResponse.result = SResponseType.success
                /** 对象 */
                sCreateResponse
            } else {
                /** 描述 */
                sCreateResponse.message = "不可以传空列表"
                /** 对象 */
                return sCreateResponse
            }
        } catch (e: Exception) {
            e.printStackTrace()
            sCreateResponse.message = e.message!!
            sCreateResponse
        }
    }

    /**
     * 批量删除管线信息
     *
     * @param idList    管线对象列表
     * @return 返回结果
     */
    fun deletes(@RequestBody idList: ArrayList<Relation>): SBaseResponse {
        /** 返回结果对象 */
        val sBaseResponse = SBaseResponse()
        /** 返回结果状态 */
        sBaseResponse.result = SResponseType.failure
        return try {
            /** 列表不可以为空 */
            if (!idList.isNullOrEmpty()) {
                /** 遍历管线信息列表 */
                for (relation in idList) {
                    /** 校验必填信息点 */
                    if (relation.id.isNullOrEmpty() || relation.relationId.isNullOrEmpty()) {
                        sBaseResponse.message = "注意接口说明必填字段"
                        return sBaseResponse
                    }
                }

                /** 遍历管线信息列表 */
                for (relation in idList) {
                    /** 删除对象 */
                    delete(SFilter.eq("id", relation.id!!), SFilter.eq("relationId", relation.relationId!!))
                }

                /** 返回结果状态 */
                sBaseResponse.result = SResponseType.success
            }
            /** 返回结果对象 */
            sBaseResponse
        } catch (e: Exception) {
            e.printStackTrace()
            /** 返回结果，状态、以及报错信息 */
            SBaseResponse(SResponseType.failure,e.message!!)
        }
    }


}