package com.vmware.vshield.flow.appvisibility.facade.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.vmware.vshield.app.global.AppConstants;
import com.vmware.vshield.firewall.dto.ObjectType;
import com.vmware.vshield.flow.appvisibility.facade.AppVisibilityRuleContainerFacade;
import com.vmware.vshield.flow.appvisibility.model.AppVisibilityRuleContainer;
import com.vmware.vshield.flow.appvisibility.service.IAppVisibilityRuleRecommendationService;
import com.vmware.vshield.vsm.application.service.ApplicationService;
import com.vmware.vshield.vsm.applicationgroup.model.ApplicationGroup;
import com.vmware.vshield.vsm.applicationgroup.service.ApplicationGroupService;
import com.vmware.vshield.vsm.aspects.security.VsmSecured;
import com.vmware.vshield.vsm.common.CommonConstants;
import com.vmware.vshield.vsm.common.DomainObjectPageAttribute;
import com.vmware.vshield.vsm.converter.ApplicationDtoConverter;
import com.vmware.vshield.vsm.converter.ApplicationGroupDtoConverter;
import com.vmware.vshield.vsm.converter.DomainObjectFilterConverter;
import com.vmware.vshield.vsm.converter.IPSetDtoConverter;
import com.vmware.vshield.vsm.converter.PagingInfoConverter;
import com.vmware.vshield.vsm.converter.SecurityGroupDtoConverter;
import com.vmware.vshield.vsm.dto.ApplicationDto;
import com.vmware.vshield.vsm.dto.ApplicationGroupDto;
import com.vmware.vshield.vsm.dto.DataPage;
import com.vmware.vshield.vsm.dto.ExtendedAttributeDto;
import com.vmware.vshield.vsm.dto.IPSetDto;
import com.vmware.vshield.vsm.dto.PagingInfo;
import com.vmware.vshield.vsm.dto.QueryOperator;
import com.vmware.vshield.vsm.dto.SecurityGroupDto;
import com.vmware.vshield.vsm.filter.DomainObjectFilter;
import com.vmware.vshield.vsm.ipset.service.IPSetService;
import com.vmware.vshield.vsm.model.Application;
import com.vmware.vshield.vsm.model.ExtendedAttribute;
import com.vmware.vshield.vsm.model.IPSet;
import com.vmware.vshield.vsm.security.model.Permission;
import com.vmware.vshield.vsm.securitygroup.model.SecurityGroup;
import com.vmware.vshield.vsm.securitygroup.service.SecurityGroupService;
import com.vmware.vshield.vsm.utils.Logger;

/**
 * Implements AppVisibilityRulesFacade interface. Provides methods that allows
 * management of firewall rules related operations via AppVisibility tool.
 *
 */
@Service
public class AppVisibilityRuleContainerFacadeImpl implements AppVisibilityRuleContainerFacade {

    Logger logger = Logger.getLogger();

    @Autowired
    IAppVisibilityRuleRecommendationService ruleRecommendationService;
    @Autowired
    private IPSetService ipSetService;
    @Autowired
    private SecurityGroupService securityGroupService;
    @Autowired
    private ApplicationService applicationService;
    @Autowired
    private ApplicationGroupService applicationGroupService;
    @Autowired
    private IPSetDtoConverter ipSetDtoConverter;
    @Autowired
    private SecurityGroupDtoConverter securityGroupDtoConverter;
    @Autowired
    private ApplicationDtoConverter applicationDtoConverter;
    @Autowired
    private ApplicationGroupDtoConverter applicationGroupDtoConverter;
    @Autowired
    private PagingInfoConverter pagingInfoConverter;
    @Autowired
    private DomainObjectFilterConverter domainObjectFilterConverter;


    @Override
    @Transactional(readOnly = true)
    @VsmSecured(objectid = CommonConstants.GLOBAL_ROOT_ID, featurename = AppConstants.AUTH_FLOW, permission = Permission.READ)
    public DataPage<IPSetDto> IPSetList(Long sessionId, String scope, PagingInfo pagingInfo, String filterValue, List<String> filterColumns){

        DomainObjectPageAttribute doPagingInfo = pagingInfoConverter.toDo(pagingInfo);

        Map<String, String> extendedAtts = new HashMap<String, String>();
        extendedAtts.put("isReadOnly", "true");
        extendedAtts.put("isHidden", "true");

        DomainObjectFilter<IPSet> filter = domainObjectFilterConverter.toDomainObjectFilter(IPSet.class, filterValue, filterColumns, extendedAtts, QueryOperator.NOT_EQUAL);



        List<AppVisibilityRuleContainer> containers = ruleRecommendationService.getFilteredContainers(sessionId,
                ObjectType.IP_SET, true, filterValue);

        if (containers != null) {
            ArrayList<String> unPublishedEntitiesIds = new ArrayList<String>();
              for (AppVisibilityRuleContainer container : containers) {
                  unPublishedEntitiesIds.add(container.getValue());
              }
              filter.setObjectIds(unPublishedEntitiesIds);
          }

        List<IPSet> ipSets = null;

        if (scope == null) {
            ipSets = ipSetService.list(doPagingInfo, filter);
        } else {
            ipSets = ipSetService.list(scope, doPagingInfo, filter);
        }
        pagingInfo.setTotalCount(doPagingInfo.getTotalCount());

        List<IPSetDto> dtos = new ArrayList<IPSetDto>();
        IPSetDto dto;
        for(IPSet set: ipSets) {
            dto = ipSetDtoConverter.toDto(set);
            dtos.add(dto);
        }

        DataPage<IPSetDto> dataPage = new DataPage<IPSetDto>();
        dataPage.setData(dtos);
        dataPage.setPagingInfo(pagingInfo);

        return dataPage;
    }

    @Override
    @Transactional(readOnly = true)
    @VsmSecured(objectid = CommonConstants.GLOBAL_ROOT_ID, featurename = AppConstants.AUTH_FLOW, permission = Permission.READ)
    public DataPage<SecurityGroupDto> securityGroupList(Long sessionId, String scope, PagingInfo pagingInfo, String filterValue, List<String> filterColumns){

        DomainObjectPageAttribute doPagingInfo = pagingInfoConverter.toDo(pagingInfo);

        Map<String, String> extendedAtts = new HashMap<String, String>();
        extendedAtts.put("isReadOnly", "true");
        extendedAtts.put("isHidden", "true");

        DomainObjectFilter<SecurityGroup> filter = domainObjectFilterConverter.toDomainObjectFilter(SecurityGroup.class, filterValue, filterColumns, extendedAtts, QueryOperator.NOT_EQUAL);



        List<AppVisibilityRuleContainer> containers = ruleRecommendationService.getFilteredContainers(sessionId,
                ObjectType.SECURITY_GROUP, true, filterValue);

        if (containers != null) {
            ArrayList<String> unPublishedEntitiesIds = new ArrayList<String>();
              for (AppVisibilityRuleContainer container : containers) {
                  unPublishedEntitiesIds.add(container.getValue());
              }
              filter.setObjectIds(unPublishedEntitiesIds);
          }

        List<SecurityGroup> securityGroups = null;

        if (scope == null) {
            securityGroups = securityGroupService.list(doPagingInfo, filter);
        } else {
            securityGroups = securityGroupService.list(scope, doPagingInfo, filter);
        }
        pagingInfo.setTotalCount(doPagingInfo.getTotalCount());

        List<SecurityGroupDto> dtos = new ArrayList<SecurityGroupDto>();
        SecurityGroupDto dto;


        logger.debug("sec-groups: " + securityGroups);
        logger.debug("sec-groups-length: " + securityGroups.size());
        for(SecurityGroup set: securityGroups) {
            Set<ExtendedAttribute> extAttrs = set.getExtendedAttributes();
            if(extAttrs != null) {
                for(ExtendedAttribute ettrDto : extAttrs){
                    if( ettrDto != null && "isHidden".equals(ettrDto.getName()) && "true".equals(ettrDto.getValue())){
                        logger.debug("dto-value: " + set);
                        logger.debug("SecurityGroupError - got hidden attribute so skipping it lalal");
                    }else {
                        dto = securityGroupDtoConverter.toDto(set);
                        dtos.add(dto);
                        logger.debug("added-dto: " + dtos);
                        logger.debug("added-dto-length: " + dtos.size());
                    }
                }
            }

        }

        logger.debug("final-dto: " + dtos);
        logger.debug("final-dto-length: " + dtos.size());


        DataPage<SecurityGroupDto> dataPage = new DataPage<SecurityGroupDto>();
        dataPage.setData(dtos);
        dataPage.setPagingInfo(pagingInfo);

        return dataPage;
    }

    @Override
    @Transactional(readOnly = true)
    @VsmSecured(objectid = CommonConstants.GLOBAL_ROOT_ID, featurename = AppConstants.AUTH_FLOW, permission = Permission.READ)
    public DataPage<ApplicationDto> applicationList(Long sessionId, String scope, PagingInfo pagingInfo, String filterValue, List<String> filterColumns){

        DomainObjectPageAttribute doPagingInfo = pagingInfoConverter.toDo(pagingInfo);

        Map<String, String> extendedAtts = new HashMap<String, String>();
        extendedAtts.put("isReadOnly", "true");
        extendedAtts.put("isHidden", "true");

        DomainObjectFilter<Application> filter = domainObjectFilterConverter.toDomainObjectFilter(Application.class, filterValue, filterColumns, extendedAtts, QueryOperator.NOT_EQUAL);

        ArrayList<String> unPublishedEntitiesIds = new ArrayList<String>();

        List<AppVisibilityRuleContainer> containers = ruleRecommendationService.getFilteredContainers(sessionId,
                ObjectType.APPLICATION, true, filterValue);

        if (containers != null) {
              for (AppVisibilityRuleContainer container : containers) {
                  unPublishedEntitiesIds.add(container.getValue());
              }
              filter.setObjectIds(unPublishedEntitiesIds);
          }

        List<Application> applications = null;

        if (scope == null) {
            applications = applicationService.list(doPagingInfo, filter);
        } else {
            applications = applicationService.list(scope, doPagingInfo, filter);
        }
        pagingInfo.setTotalCount(doPagingInfo.getTotalCount());

        List<ApplicationDto> dtos = new ArrayList<ApplicationDto>();
        ApplicationDto dto;
        for(Application set: applications) {
            dto = applicationDtoConverter.toDto(set);
            dtos.add(dto);
        }

        DataPage<ApplicationDto> dataPage = new DataPage<ApplicationDto>();
        dataPage.setData(dtos);
        dataPage.setPagingInfo(pagingInfo);

        return dataPage;
    }

    @Override
    @Transactional(readOnly = true)
    @VsmSecured(objectid = CommonConstants.GLOBAL_ROOT_ID, featurename = AppConstants.AUTH_FLOW, permission = Permission.READ)
    public DataPage<ApplicationGroupDto> applicationGroupList(Long sessionId, String scope, PagingInfo pagingInfo, String filterValue, List<String> filterColumns){

        DomainObjectPageAttribute doPagingInfo = pagingInfoConverter.toDo(pagingInfo);

        Map<String, String> extendedAtts = new HashMap<String, String>();
        extendedAtts.put("isReadOnly", "true");
        extendedAtts.put("isHidden", "true");

        DomainObjectFilter<ApplicationGroup> filter = domainObjectFilterConverter.toDomainObjectFilter(ApplicationGroup.class, filterValue, filterColumns, extendedAtts, QueryOperator.NOT_EQUAL);

        ArrayList<String> unPublishedEntitiesIds = new ArrayList<String>();

        List<AppVisibilityRuleContainer> containers = ruleRecommendationService.getFilteredContainers(sessionId,
                ObjectType.APPLICATON_GROUP, true, filterValue);

        if (containers != null) {
              for (AppVisibilityRuleContainer container : containers) {
                  unPublishedEntitiesIds.add(container.getValue());
              }
              filter.setObjectIds(unPublishedEntitiesIds);
          }

        List<ApplicationGroup> applicationGroups = null;

        if (scope == null) {
            applicationGroups = applicationGroupService.list(doPagingInfo, filter);
        } else {
            applicationGroups = applicationGroupService.list(scope, doPagingInfo, filter);
        }
        pagingInfo.setTotalCount(doPagingInfo.getTotalCount());

        List<ApplicationGroupDto> dtos = new ArrayList<ApplicationGroupDto>();
        ApplicationGroupDto dto;
        for(ApplicationGroup set: applicationGroups) {
            dto = applicationGroupDtoConverter.toDto(set);
            dtos.add(dto);
        }

        DataPage<ApplicationGroupDto> dataPage = new DataPage<ApplicationGroupDto>();
        dataPage.setData(dtos);
        dataPage.setPagingInfo(pagingInfo);

        return dataPage;
    }
}