/*
 *  Copyright 2019 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.web.frontoffice.search.metamodel.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.math3.util.IntegerSequence.Incrementor;

import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.contenttype.indexing.IndexingField;
import org.ametys.cms.contenttype.indexing.MetadataIndexingField;
import org.ametys.cms.repository.Content;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.cms.search.ui.model.SearchUICriterion;
import org.ametys.cms.search.ui.model.impl.IndexingFieldSearchUICriterion;
import org.ametys.cms.search.ui.model.impl.SystemSearchUICriterion;
import org.ametys.cms.tag.TagProviderExtensionPoint;
import org.ametys.core.util.JSONUtils;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;
import org.ametys.web.frontoffice.search.metamodel.AdditionalParameterValueMap;
import org.ametys.web.frontoffice.search.metamodel.Returnable;
import org.ametys.web.frontoffice.search.metamodel.ReturnableExtensionPoint;
import org.ametys.web.frontoffice.search.metamodel.SearchCriterionDefinition;
import org.ametys.web.frontoffice.search.metamodel.Searchable;

/**
 * Abstract class for all {@link Searchable} based on {@link Content}s
 */
public abstract class AbstractContentBasedSearchable extends AbstractParameterAdderSearchable implements Initializable, Contextualizable, Disposable
{
    // Push ids of System Properties you do not want to appear in the list
    private static final List<String> __EXCLUDED_SYSTEM_PROPERTIES = Arrays.asList("site", 
                                                                                    "parents", 
                                                                                    "workflowStep");
    // Push ids of Indexing Fields you do not want to appear in the list (for instance title which is handled separately)
    private static final List<String> __EXCLUDED_INDEXING_FIELD = Arrays.asList("title");
    
    /** The label */
    protected I18nizableText _label;
    /** The criteria position */
    protected int _criteriaPosition;
    /** The page returnable */
    protected Returnable _pageReturnable;
    /** The associated content returnable */
    protected Returnable _associatedContentReturnable;
    
    private Context _context;
    private SystemPropertyExtensionPoint _systemPropertyEP;
    private ContentTypeExtensionPoint _cTypeEP;
    private AmetysObjectResolver _ametysObjectResolver;
    private TagProviderExtensionPoint _tagProviderEP;
    private JSONUtils _jsonUtils;

    private List<ContentSearchCriterionDefinition> _systemPropertySearchCriterionDefs;
    private Map<String, Collection<CriterionDefinitionAndSourceContentType>> _indexingFieldSearchCriterionDefsCache;
    private ContentSearchCriterionDefinition _titleIndexingFieldSearchCriterionDefCache;
    private Set<ThreadSafeComponentManager<?>> _managers;
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        super.configure(configuration);
        _label = I18nizableText.parseI18nizableText(configuration.getChild("label"), "plugin." + _pluginName);
        _criteriaPosition = configuration.getChild("criteriaPosition").getValueAsInteger();
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        ReturnableExtensionPoint returnableEP = (ReturnableExtensionPoint) manager.lookup(ReturnableExtensionPoint.ROLE);
        _pageReturnable = returnableEP.getExtension(PageReturnable.ROLE);
        _associatedContentReturnable = returnableEP.getExtension(associatedContentReturnableRole());
        _systemPropertyEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _tagProviderEP = (TagProviderExtensionPoint) manager.lookup(TagProviderExtensionPoint.ROLE);
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
    }
    
    /**
     * The Avalon Role for the associated Content Returnable
     * @return The Avalon Role for the associated Content Returnable
     */
    protected abstract String associatedContentReturnableRole();
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void initialize() throws Exception
    {
        _managers = new HashSet<>();
        
        _systemPropertySearchCriterionDefs = new ArrayList<>();
        for (String propId : _systemPropertyEP.getSearchProperties())
        {
            if (__EXCLUDED_SYSTEM_PROPERTIES.contains(propId))
            {
                continue;
            }
            
            ContentSearchCriterionDefinition def = _getSystemPropSearchCriterionDef(propId);
            _systemPropertySearchCriterionDefs.add(def);
        }
        
        _indexingFieldSearchCriterionDefsCache = new HashMap<>();
    }
    
    private ContentSearchCriterionDefinition _getSystemPropSearchCriterionDef(String propId)
    {
        try
        {
            ThreadSafeComponentManager<SearchUICriterion> searchCriterionManager = new ThreadSafeComponentManager<>();
            _managers.add(searchCriterionManager);
            searchCriterionManager.setLogger(getLogger());
            searchCriterionManager.contextualize(_context);
            searchCriterionManager.service(_manager);
            
            String role = propId;
            Configuration criteriaConf = _getSystemCriteriaConfiguration(propId);
            searchCriterionManager.addComponent(_pluginName, null, role, SystemSearchUICriterion.class, criteriaConf);
            
            searchCriterionManager.initialize();
            
            SearchUICriterion criterion = searchCriterionManager.lookup(role);
            String id = getSystemPropertyCriterionDefinitionPrefix() + role;
            ContentSearchCriterionDefinition criterionDef = _criterionDefinition(id, criterion);
            return criterionDef;
        }
        catch (Exception e)
        {
            throw new RuntimeException("An error occured when retrieving SystemPropertySearchCriterionDefinitions", e);
        }
    }
    
    private ContentSearchCriterionDefinition _criterionDefinition(String id, SearchUICriterion criterion)
    {
        if (criterion instanceof SystemSearchUICriterion)
        {
            SystemSearchUICriterion systemCriterion = (SystemSearchUICriterion) criterion;
            if ("tags".equals(systemCriterion.getSystemPropertyId()))
            {
                return new TagSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.empty(), _tagProviderEP, _jsonUtils);
            }
        }
        return new ContentSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.empty());
    }
    
    /**
     * Gets the prefix for the ids of system property criterion definitions
     * @return the prefix for the ids of system property criterion definitions
     */
    protected String getSystemPropertyCriterionDefinitionPrefix()
    {
        return getCriterionDefinitionPrefix() + "systemProperty$";
    }
    
    /**
     * Gets the prefix for criterion definitions
     * @return the prefix for criterion definitions
     */
    protected abstract String getCriterionDefinitionPrefix();
    
    private Configuration _getSystemCriteriaConfiguration(String propertyId)
    {
        DefaultConfiguration conf = new DefaultConfiguration("criteria");
        
        DefaultConfiguration propConf = new DefaultConfiguration("systemProperty");
        propConf.setAttribute("name", propertyId);
        conf.addChild(propConf);
        
        // By default, SystemSearchUICriterion sets the multiple status to 'false', so here explicitly copy the multiple status from the property itself
        SystemProperty property = _systemPropertyEP.getExtension(propertyId);
        conf.setAttribute("multiple", property.isMultiple());
        
        return conf;
    }
    
    @Override
    public void dispose()
    {
        _systemPropertySearchCriterionDefs
                .forEach(ContentSearchCriterionDefinition::dispose);
        _systemPropertySearchCriterionDefs.clear();
        
        _indexingFieldSearchCriterionDefsCache.values()
                .stream()
                .flatMap(Collection::stream)
                .map(CriterionDefinitionAndSourceContentType::criterionDefinition)
                .forEach(ContentSearchCriterionDefinition::dispose);
        _indexingFieldSearchCriterionDefsCache.clear();
        
        _managers.forEach(ThreadSafeComponentManager::dispose);
        _managers.clear();
    }
    
    @Override
    public I18nizableText getLabel()
    {
        return _label;
    }
    
    @Override
    public int criteriaPosition()
    {
        return _criteriaPosition;
    }
    
    @Override
    public Collection<SearchCriterionDefinition> getCriteria(AdditionalParameterValueMap additionalParameterValues)
    {
        Collection<SearchCriterionDefinition> criteria = new ArrayList<>();
        
        // Content types
        Collection<String> contentTypes = getContentTypes(additionalParameterValues);
        
        // Special case for title
        criteria.add(_getTitleIndexingFieldSearchCriterionDef());
        
        // Indexing fields
        Collection<CriterionDefinitionAndSourceContentType> indexingFieldCriterionDefs = _getIndexingFieldSearchCriterionDefs(contentTypes);
        criteria.addAll(_finalIndexingFieldCriterionDefs(indexingFieldCriterionDefs));
        
        // System properties
        criteria.addAll(_systemPropertySearchCriterionDefs);
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("#getCriteria for contentTypes '{}' returned '{}'", 
                    contentTypes, 
                    criteria.stream()
                        .map(SearchCriterionDefinition::getId)
                        .collect(Collectors.toList()));
        }
        
        return criteria;
    }
    
    /**
     * Gets the content types which will be used to retrieve the criteria relative to the Indexing Model
     * @param additionalParameterValues The additional parameter values
     * @return the content types which will be used to retrieve the criteria relative to the Indexing Model
     */
    protected abstract Collection<String> getContentTypes(AdditionalParameterValueMap additionalParameterValues);
    
    private synchronized Collection<CriterionDefinitionAndSourceContentType> _getIndexingFieldSearchCriterionDefs(Collection<String> contentTypeIds)
    {
        return contentTypeIds
                .stream()
                .map(this::_getIndexingFieldSearchCriterionDefs)
                .flatMap(Collection::stream)
                .collect(Collectors.toList());
    }
    
    private Collection<CriterionDefinitionAndSourceContentType> _getIndexingFieldSearchCriterionDefs(String contentTypeId)
    {
        if (_indexingFieldSearchCriterionDefsCache.containsKey(contentTypeId))
        {
            // found in cache
            Collection<CriterionDefinitionAndSourceContentType> defs = _indexingFieldSearchCriterionDefsCache.get(contentTypeId);
            getLogger().info("IndexingFieldSearchUICriteria for '{}' cache hit ({}).", contentTypeId, defs);
            return defs;
        }
        else
        {
            ContentType contentType = _cTypeEP.getExtension(contentTypeId);
            Collection<IndexingField> indexingModelFields = _getIndexingFields(contentType);
            Collection<CriterionDefinitionAndSourceContentType> indexingFieldSearchCriterionDefs = _createIndexingFieldSearchCriterionDefs(indexingModelFields, contentType);
            // add in cache
            _indexingFieldSearchCriterionDefsCache.put(contentTypeId, indexingFieldSearchCriterionDefs);
            getLogger().info("IndexingFieldSearchUICriteria for '{}' cache miss. They will be created and added in cache ({}).", contentTypeId, indexingFieldSearchCriterionDefs);
            return indexingFieldSearchCriterionDefs;
        }
    }
    
    private Collection<IndexingField> _getIndexingFields(ContentType contentType)
    {
        return contentType
                .getIndexingModel()
                .getFields();
    }
    
    private Collection<CriterionDefinitionAndSourceContentType> _createIndexingFieldSearchCriterionDefs(Collection<IndexingField> indexingModelFields, ContentType requestedContentType)
    {
        List<CriterionDefinitionAndSourceContentType> criteria = new ArrayList<>();
        String requestedContentTypeId = requestedContentType.getId();
        
        try
        {
            ThreadSafeComponentManager<SearchUICriterion> searchCriterionManager = new ThreadSafeComponentManager<>();
            _managers.add(searchCriterionManager);
            searchCriterionManager.setLogger(getLogger());
            searchCriterionManager.contextualize(_context);
            searchCriterionManager.service(_manager);
            List<Pair<String, ContentType>> searchCriteriaRoles = new ArrayList<>();
            
            for (IndexingField indexingField : indexingModelFields)
            {
                if (__EXCLUDED_INDEXING_FIELD.contains(indexingField.getName()))
                {
                    continue;
                }
                // Get only first-level field (ignore composites and repeaters)
                if (indexingField.getType() != MetadataType.COMPOSITE)
                {
                    ContentType fromContentType = Optional.of(indexingField)
                            .filter(MetadataIndexingField.class::isInstance)
                            .map(MetadataIndexingField.class::cast)
                            .map(MetadataIndexingField::getMetadataDefinition)
                            .map(MetadataDefinition::getReferenceContentType)
                            .map(_cTypeEP::getExtension)
                            .orElse(requestedContentType);
                    
                    final String path = indexingField.getName();
                    final String role = path;
                    Configuration criteriaConf = _getIndexingFieldCriteriaConfiguration(path, Optional.of(requestedContentTypeId));
                    searchCriterionManager.addComponent(_pluginName, null, role, IndexingFieldSearchUICriterion.class, criteriaConf);
                    
                    searchCriteriaRoles.add(Pair.of(role, fromContentType));
                }
            }
            
            searchCriterionManager.initialize();
            
            final String prefix = getIndexingFieldCriterionDefinitionPrefix();
            for (Pair<String, ContentType> roleAndCType : searchCriteriaRoles)
            {
                String searchCriteriaRole = roleAndCType.getLeft();
                ContentType fromContentType = roleAndCType.getRight();
                SearchUICriterion criterion = searchCriterionManager.lookup(searchCriteriaRole);
                String id = prefix + fromContentType.getId() + "$" + searchCriteriaRole;
                ContentSearchCriterionDefinition criterionDef = _criterionDefinition(id, criterion, fromContentType);
                criteria.add(new CriterionDefinitionAndSourceContentType(criterionDef, fromContentType));
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException("An error occured when retrieving IndexingFieldSearchCriterionDefinitions", e);
        }
        
        criteria.sort(Comparator.comparing(
            critDefAndSourceCtype -> critDefAndSourceCtype._contentTypeId, 
            new ContentTypeComparator(requestedContentType, _cTypeEP)
                .reversed()));
        return criteria;
    }
    
    private ContentSearchCriterionDefinition _criterionDefinition(String id, SearchUICriterion criterion, ContentType fromContentType)
    {
        boolean isAttributeContent = criterion.getType() == MetadataType.CONTENT;
        return isAttributeContent 
                ? new ContentAttributeContentSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.of(fromContentType), _ametysObjectResolver, _cTypeEP)
                : new ContentSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.of(fromContentType));
    }
    
    private static class ContentTypeComparator implements Comparator<String>
    {
        /* The purpose here is to fill a Map with an Integer
         * for each content type id in the hierarchy, and to base
         * the comparator on those values.
         * For instance, if we have the following hierarchy:
         * 
         * _______A______
         * _____/___\____
         * _____B____C___
         * ____/_\___|___
         * ___B1_B2__C1__
         * 
         * which means that <A extends B,C> & <B extends B1,B2> & <C extends C1>
         * then we want to generate the Map:
         * {A=1, B=2, B1=3, B2=4, C=5, C1=6}
         * (which means we do a depth-first search with pre-order i.e. the children are processed after their parent, from left to right)
         * (See also https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR))
         * 
         * Then with this map, we generate the following order:
         * [A, B, B1, B2, C, C1]
         * (which will then be reversed by #_createIndexingFieldSearchCriterionDefs)
         */
        String _baseCTypeId;
        private Map<String, Integer> _orderByContentType;
        
        ContentTypeComparator(ContentType baseContentType, ContentTypeExtensionPoint cTypeEP)
        {
            _baseCTypeId = baseContentType.getId();
            _orderByContentType = new HashMap<>();
            Incrementor incrementor = Incrementor.create()
                    .withStart(0)
                    .withMaximalCount(Integer.MAX_VALUE);
            _fillOrderByContentType(baseContentType, incrementor, cTypeEP);
        }
        
        private void _fillOrderByContentType(ContentType contentType, Incrementor incrementor, ContentTypeExtensionPoint cTypeEP)
        {
            String contentTypeId = contentType.getId();
            incrementor.increment();
            _orderByContentType.put(contentTypeId, incrementor.getCount());
            Arrays.asList(contentType.getSupertypeIds())
                    .stream()
                    .sequential()
                    .filter(id -> !_orderByContentType.containsKey(id)) // do not re-process already encountered content types
                    .map(cTypeEP::getExtension)
                    .filter(Objects::nonNull)
                    .forEachOrdered(childContentType -> _fillOrderByContentType(childContentType, incrementor, cTypeEP));
        }
        
        @Override
        public int compare(String c1ContentTypeId, String c2ContentTypeId)
        {
            if (c1ContentTypeId.equals(c2ContentTypeId))
            {
                return 0;
            }
            
            if (!_orderByContentType.containsKey(c1ContentTypeId) || !_orderByContentType.containsKey(c2ContentTypeId))
            {
                String message = String.format("An unexpected error occured with the ContentType comparator for base '%s', cannot compare '%s' and '%s'.\nThe orderByContentType map is: %s", _baseCTypeId, c1ContentTypeId, c2ContentTypeId, _orderByContentType.toString());
                throw new IllegalStateException(message);
            }
            
            return Integer.compare(_orderByContentType.get(c1ContentTypeId), _orderByContentType.get(c2ContentTypeId));
        }
    }
    
    
    private Collection<ContentSearchCriterionDefinition> _finalIndexingFieldCriterionDefs(Collection<CriterionDefinitionAndSourceContentType> indexingFieldCriterionDefs)
    {
        return indexingFieldCriterionDefs
                .stream()
                // we want to not have duplicates, i.e. having same indexing field brought by two ContentTypes because it is declared in their common super ContentType
                // this is done by calling #distinct(), and thus this is based on the #equals impl of CriterionDefinitionAndSourceContentType
                .distinct()
                .map(CriterionDefinitionAndSourceContentType::criterionDefinition)
                .collect(Collectors.toList());
    }
    
    private synchronized ContentSearchCriterionDefinition _getTitleIndexingFieldSearchCriterionDef()
    {
        if (_titleIndexingFieldSearchCriterionDefCache != null)
        {
            // found in cache
            getLogger().info("'title' IndexingFieldSearchUICriterion cache hit.");
        }
        else
        {
            // add in cache
            _titleIndexingFieldSearchCriterionDefCache = _createTitleIndexingFieldSearchCriterionDef();
            getLogger().info("'title' IndexingFieldSearchUICriterion cache miss. It will be created and added in cache.");
        }
        return _titleIndexingFieldSearchCriterionDefCache;
    }
    
    private ContentSearchCriterionDefinition _createTitleIndexingFieldSearchCriterionDef()
    {
        try
        {
            ThreadSafeComponentManager<SearchUICriterion> searchCriterionManager = new ThreadSafeComponentManager<>();
            _managers.add(searchCriterionManager);
            searchCriterionManager.setLogger(getLogger());
            searchCriterionManager.contextualize(_context);
            searchCriterionManager.service(_manager);
            
            String searchCriteriaRole = "title";
            Configuration criteriaConf = _getIndexingFieldCriteriaConfiguration(searchCriteriaRole, Optional.empty());
            searchCriterionManager.addComponent(_pluginName, null, searchCriteriaRole, IndexingFieldSearchUICriterion.class, criteriaConf);
            
            searchCriterionManager.initialize();
            
            SearchUICriterion criterion = searchCriterionManager.lookup(searchCriteriaRole);
            String id = getIndexingFieldCriterionDefinitionPrefix() + "_common$" + searchCriteriaRole;
            return new ContentSearchCriterionDefinition(id, _pluginName, Optional.of(this), criterion, Optional.empty());
        }
        catch (Exception e)
        {
            throw new RuntimeException("An error occured when retrieving IndexingFieldSearchCriterionDefinitions", e);
        }
    }
    
    /**
     * Gets the prefix for the ids of indexing field criterion definitions
     * @return the prefix for the ids of indexing field criterion definitions
     */
    protected String getIndexingFieldCriterionDefinitionPrefix()
    {
        return getCriterionDefinitionPrefix() + "indexingField$";
    }
    
    private Configuration _getIndexingFieldCriteriaConfiguration(String path, Optional<String> contentTypeId)
    {
        DefaultConfiguration criteriaConf = new DefaultConfiguration("criteria");
        DefaultConfiguration metaConf = new DefaultConfiguration("field");
        criteriaConf.addChild(metaConf);
        metaConf.setAttribute("path", path);
        
        DefaultConfiguration cTypesConf = new DefaultConfiguration("contentTypes");
        criteriaConf.addChild(cTypesConf);
        contentTypeId.ifPresent(id -> cTypesConf.setAttribute("baseId", id));
        
        return criteriaConf;
    }
    
    @Override
    public Collection<Returnable> relationsWith()
    {
        return Arrays.asList(_pageReturnable, _associatedContentReturnable);
    }
    
    // wraps a CriterionDefinition and where it comes from
    private static class CriterionDefinitionAndSourceContentType
    {
        String _contentTypeId;
        private ContentSearchCriterionDefinition _critDef;
        private String _critDefId;
        
        CriterionDefinitionAndSourceContentType(ContentSearchCriterionDefinition critDef, ContentType contentType)
        {
            _critDef = critDef;
            _critDefId = critDef.getId();
            _contentTypeId = contentType.getId();
        }
        
        ContentSearchCriterionDefinition criterionDefinition()
        {
            return _critDef;
        }
        
        @Override
        public String toString()
        {
            return _critDefId;
        }

        @Override
        public int hashCode()
        {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((_contentTypeId == null) ? 0 : _contentTypeId.hashCode());
            result = prime * result + ((_critDefId == null) ? 0 : _critDefId.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (obj == null)
            {
                return false;
            }
            if (!(obj instanceof CriterionDefinitionAndSourceContentType))
            {
                return false;
            }
            CriterionDefinitionAndSourceContentType other = (CriterionDefinitionAndSourceContentType) obj;
            if (_contentTypeId == null)
            {
                if (other._contentTypeId != null)
                {
                    return false;
                }
            }
            else if (!_contentTypeId.equals(other._contentTypeId))
            {
                return false;
            }
            if (_critDefId == null)
            {
                if (other._critDefId != null)
                {
                    return false;
                }
            }
            else if (!_critDefId.equals(other._critDefId))
            {
                return false;
            }
            return true;
        }
    }
}