package net.srt.api;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import net.srt.api.module.data.governance.DataMetadataCollectApi;
import net.srt.api.module.data.governance.constant.DbType;
import net.srt.api.module.data.governance.dto.DataGovernanceMetadataCollectDto;
import net.srt.api.module.data.governance.dto.DataGovernanceMetadataCollectRecordDto;
import net.srt.api.module.data.governance.dto.DataGovernanceMetadataDto;
import net.srt.api.module.data.governance.dto.DataGovernanceMetadataPropertyDto;
import net.srt.convert.MetadataCollectConvert;
import net.srt.convert.MetadataCollectRecordConvert;
import net.srt.convert.MetadataConvert;
import net.srt.convert.MetadataPropertyConvert;
import net.srt.entity.MetadataCollectEntity;
import net.srt.entity.MetadataCollectRecordEntity;
import net.srt.entity.MetadataEntity;
import net.srt.entity.MetadataPropertyEntity;
import net.srt.framework.common.utils.Result;
import net.srt.service.MetadataCollectRecordService;
import net.srt.service.MetadataCollectService;
import net.srt.service.MetadataPropertyService;
import net.srt.service.MetadataService;
import org.springframework.web.bind.annotation.RestController;

import java.nio.file.Watchable;
import java.util.List;

/**
 * @BelongsProject: srt_cloud
 * @BelongsPackage: net.srt.api
 * @Author: jpz
 * @CreateTime: 2023/12/25 19:45
 */
@RestController
@RequiredArgsConstructor
public class MetadataCollectApiImpl implements DataMetadataCollectApi {
    private final MetadataService metadataService;
    private final MetadataCollectService metadataCollectService;
    private final MetadataCollectRecordService metadataCollectRecordService;
    private final MetadataPropertyService metadataPropertyService;
    @Override
    public Result<DataGovernanceMetadataCollectDto> getById(Long id) {
        return Result.ok(MetadataCollectConvert.INSTANCE.convertDto(metadataCollectService.getById(id)));
    }

    @Override
    public DataGovernanceMetadataCollectRecordDto addCollectRecord(DataGovernanceMetadataCollectRecordDto collectRecordDto) {
        MetadataCollectRecordEntity convert = MetadataCollectRecordConvert.INSTANCE.convert(collectRecordDto);
        metadataCollectRecordService.save(convert);
        collectRecordDto.setId(convert.getId());
        return collectRecordDto;
    }

    @Override
    public void upCollectRecord(DataGovernanceMetadataCollectRecordDto collectRecordDto) {
        metadataCollectRecordService.updateById(MetadataCollectRecordConvert.INSTANCE.convert(collectRecordDto));
    }

    @Override
    public Result<DataGovernanceMetadataDto> getByParentIdAndDatasourceId(Long parnetId, Long datasourceId) {
        LambdaQueryWrapper<MetadataEntity> wrapper= Wrappers.lambdaQuery();
        wrapper.eq(MetadataEntity::getParentId,parnetId).eq(MetadataEntity::getDatasourceId,datasourceId).last("limit 1");
        return Result.ok(MetadataConvert.INSTANCE.convertDto(metadataService.getOne(wrapper)));
    }

    @Override
    public Result<DataGovernanceMetadataDto> getMetadataById(Long metadataId) {
        return Result.ok(MetadataConvert.INSTANCE.convertDto(metadataService.getById(metadataId)));
    }

    @Override
    public Result<DataGovernanceMetadataDto> getByParentIdAndOtherInfo(Long parnetId, Long datasourceId, String code, Long metamodelId) {
        LambdaQueryWrapper<MetadataEntity> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(MetadataEntity::getParentId,parnetId).eq(datasourceId!=null,MetadataEntity::getDatasourceId,datasourceId)
                .eq(MetadataEntity::getCode,code)
                .eq(datasourceId==null,MetadataEntity::getDbType, DbType.MIDDLE_DB.getValue())
                .eq(MetadataEntity::getMetamodelId,metamodelId)
                .last("limit 1");
        return Result.ok(MetadataConvert.INSTANCE.convertDto(metadataService.getOne(wrapper)));
    }

    @Override
    public DataGovernanceMetadataDto addOrUpdateMetadata(DataGovernanceMetadataDto metadataDto) {
        MetadataEntity entity=MetadataConvert.INSTANCE.convert(metadataDto);
        if (metadataDto.getId()!=null){
            metadataService.updateById(entity);
        }else{
            metadataService.save(entity);
        }
        metadataDto.setId(entity.getId());
        return metadataDto;
    }

    @Override
    public Result<DataGovernanceMetadataPropertyDto> getByPropertyIdAndMetadataId(Long propertyId, Long metadataId) {
        LambdaQueryWrapper<MetadataPropertyEntity> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(MetadataPropertyEntity::getId,propertyId).eq(MetadataPropertyEntity::getMetadataId,metadataId).last("limit 1");
        return Result.ok(MetadataPropertyConvert.INSTANCE.convertDto(metadataPropertyService.getOne(wrapper)));
    }

    @Override
    public void addOrUpdateMetadataProperty(DataGovernanceMetadataPropertyDto metadataPropertyDto) {
        if (metadataPropertyDto.getId()!=null){
            metadataPropertyService .save(MetadataPropertyConvert.INSTANCE.convert(metadataPropertyDto));
        }else {
            metadataPropertyService.updateById(MetadataPropertyConvert.INSTANCE.convert(metadataPropertyDto));
        }
    }

    @Override
    public Result<List<DataGovernanceMetadataDto>> listParentIdAndDatasourceId(Long parentId, Long datasourceId, Long metamodelId) {
        LambdaQueryWrapper<MetadataEntity> wrapper= Wrappers.lambdaQuery();
        wrapper.eq(MetadataEntity::getParentId,parentId).eq(MetadataEntity::getDatasourceId,datasourceId).eq(MetadataEntity::getMetamodelId,metamodelId);
        return Result.ok(MetadataConvert.INSTANCE.convertDtoList(metadataService.list(wrapper)));
    }

    @Override
    public void deleteMetadata(Long id) {
        metadataService.delete(id);

    }

    @Override
    public Result<DataGovernanceMetadataCollectDto> getByDatasourceId(Long id) {
        LambdaQueryWrapper<MetadataCollectEntity> wrapper=Wrappers.lambdaQuery();
        wrapper.eq(MetadataCollectEntity::getDatabaseId,id).last("limit 1");
        return Result.ok(MetadataCollectConvert.INSTANCE.convertDto(metadataCollectService.getOne(wrapper)));
    }

    @Override
    public Result<DataGovernanceMetadataDto> getMetadataByDatasourceId(Long id) {
        LambdaQueryWrapper<MetadataEntity> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(MetadataEntity::getDatasourceId,id).last("limit 1");
        return Result.ok(MetadataConvert.INSTANCE.convertDto(metadataService.getOne(wrapper)));
    }
}