package modes3.run;

import com.google.common.base.Objects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import hu.bme.mit.inf.dslreasoner.ecore2logic.EReferenceMapper_RelationsOverTypes_Trace;
import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration;
import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor;
import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsFactory;
import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsPackage;
import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion;
import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder;
import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput;
import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes;
import hu.bme.mit.inf.dslreasoner.logic.model.builder.VariableContext;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Iff;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition;
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Variable;
import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.Annotation;
import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem;
import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage;
import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult;
import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult;
import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic;
import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration;
import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicTrace;
import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor;
import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.Viatra2LogicAnnotationsPackage;
import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod;
import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorConstraints;
import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorSolver;
import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RelationLink;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml;
import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualisation;
import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.StateCoderStrategy;
import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner;
import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration;
import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualiser;
import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Predicate;
import modes3.Modes3Factory;
import modes3.Modes3ModelRoot;
import modes3.Modes3Package;
import modes3.queries.Modes3Queries;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EEnum;
import org.eclipse.emf.ecore.EEnumLiteral;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup;
import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
import org.eclipse.viatra.query.runtime.api.ViatraQueryEngineOptions;
import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchEMFBackendFactory;
import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
import org.eclipse.viatra.query.runtime.rete.matcher.ReteBackendFactory;
import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.ExclusiveRange;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.InputOutput;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ObjectExtensions;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;

@FinalFieldsConstructor
@SuppressWarnings("all")
public class Modes3ModelGenerator {
  private enum MonitoringQuery {
    closeTrains,
    
    misalignedTurnout;
  }
  
  private final Modes3ModelGenerator.MonitoringQuery monitoringQuery;
  
  private final int modelSize;
  
  private final Ecore2Logic ecore2Logic = new Ecore2Logic();
  
  private final InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic();
  
  private final Viatra2Logic viatra2Logic = new Viatra2Logic(this.ecore2Logic);
  
  private final ViatraReasoner solver = new ViatraReasoner();
  
  @Extension
  private final LogicProblemBuilder _logicProblemBuilder = new LogicProblemBuilder();
  
  public URI generate() {
    try {
      URI _xblockexpression = null;
      {
        final EcoreMetamodelDescriptor metamodel = Modes3ModelGenerator.createMetamodelDescriptor();
        Ecore2LogicConfiguration _ecore2LogicConfiguration = new Ecore2LogicConfiguration();
        final TracedOutput<LogicProblem, Ecore2Logic_Trace> metamodelLogic = this.ecore2Logic.transformMetamodel(metamodel, _ecore2LogicConfiguration);
        final Type segment = this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getSegment());
        final RelationDeclaration connectedTo = this.ecore2Logic.relationOfReference(metamodelLogic.getTrace(), 
          Modes3Package.eINSTANCE.getSegment_ConnectedTo());
        final RelationDeclaration connectedToIndicator = ((EReferenceMapper_RelationsOverTypes_Trace) metamodelLogic.getTrace().referenceMapperTrace).indicators.get(
          Modes3Package.eINSTANCE.getSegment_ConnectedTo());
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("oppositeReference ");
        String _name = connectedTo.getName();
        _builder.append(_name);
        _builder.append(" ");
        String _name_1 = connectedTo.getName();
        _builder.append(_name_1);
        final Function1<VariableContext, TermDescription> _function = (VariableContext it) -> {
          Iff _xblockexpression_1 = null;
          {
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append("src");
            final Variable src = it.addVar(_builder_1, segment);
            StringConcatenation _builder_2 = new StringConcatenation();
            _builder_2.append("trg");
            final Variable trg = it.addVar(_builder_2, segment);
            SymbolicValue _call = this._logicProblemBuilder.call(connectedToIndicator, src, trg);
            SymbolicValue _call_1 = this._logicProblemBuilder.call(connectedToIndicator, trg, src);
            _xblockexpression_1 = this._logicProblemBuilder.operator_spaceship(_call, _call_1);
          }
          return _xblockexpression_1;
        };
        final Assertion inverseAssertion = this._logicProblemBuilder.Assertion(_builder, 
          this._logicProblemBuilder.Forall(_function));
        EList<Assertion> _assertions = metamodelLogic.getOutput().getAssertions();
        _assertions.add(inverseAssertion);
        InverseRelationAssertion _createInverseRelationAssertion = Ecore2logicannotationsFactory.eINSTANCE.createInverseRelationAssertion();
        final Procedure1<InverseRelationAssertion> _function_1 = (InverseRelationAssertion it) -> {
          it.setTarget(inverseAssertion);
          it.setInverseA(connectedTo);
          it.setInverseB(connectedTo);
        };
        final InverseRelationAssertion inverseAnnotation = ObjectExtensions.<InverseRelationAssertion>operator_doubleArrow(_createInverseRelationAssertion, _function_1);
        EList<Annotation> _annotations = metamodelLogic.getOutput().getAnnotations();
        _annotations.add(inverseAnnotation);
        final List<EObject> initialModel = Modes3ModelGenerator.loadInitialModel();
        final TracedOutput<LogicProblem, Ecore2Logic_Trace> initialModelLogic = this.instanceModel2Logic.transform(metamodelLogic, initialModel);
        final ViatraQuerySetDescriptor queries = this.loadQueries();
        Viatra2LogicConfiguration _viatra2LogicConfiguration = new Viatra2LogicConfiguration();
        final TracedOutput<LogicProblem, Viatra2LogicTrace> logic = this.viatra2Logic.transformQueries(queries, initialModelLogic, _viatra2LogicConfiguration);
        ViatraReasonerConfiguration _viatraReasonerConfiguration = new ViatraReasonerConfiguration();
        final Procedure1<ViatraReasonerConfiguration> _function_2 = (ViatraReasonerConfiguration it) -> {
          it.runtimeLimit = 3600;
          final Procedure1<TypeScopes> _function_3 = (TypeScopes it_1) -> {
            it_1.minNewElements = this.modelSize;
            it_1.maxNewElements = this.modelSize;
            final Procedure1<Map<Type, Integer>> _function_4 = (Map<Type, Integer> it_2) -> {
              it_2.put(this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getTurnout()), Integer.valueOf(1));
            };
            ObjectExtensions.<Map<Type, Integer>>operator_doubleArrow(
              it_1.minNewElementsByType, _function_4);
            final Procedure1<Map<Type, Integer>> _function_5 = (Map<Type, Integer> it_2) -> {
              it_2.put(this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getTrain()), Integer.valueOf(5));
            };
            ObjectExtensions.<Map<Type, Integer>>operator_doubleArrow(
              it_1.maxNewElementsByType, _function_5);
          };
          ObjectExtensions.<TypeScopes>operator_doubleArrow(
            it.typeScopes, _function_3);
          it.solutionScope.numberOfRequiredSolutions = 1;
          it.nameNewElements = false;
          it.typeInferenceMethod = TypeInferenceMethod.PreliminaryAnalysis;
          it.stateCoderStrategy = StateCoderStrategy.Neighbourhood;
          ScopePropagatorStrategy.Polyhedral _polyhedral = new ScopePropagatorStrategy.Polyhedral(
            PolyhedralScopePropagatorConstraints.Relational, PolyhedralScopePropagatorSolver.Clp);
          it.scopePropagatorStrategy = _polyhedral;
          it.debugConfiguration.partialInterpretatioVisualiser = null;
        };
        final ViatraReasonerConfiguration config = ObjectExtensions.<ViatraReasonerConfiguration>operator_doubleArrow(_viatraReasonerConfiguration, _function_2);
        final FileSystemWorkspace workspace = new FileSystemWorkspace("output/", "");
        final LogicResult solution = this.solver.solve(logic.getOutput(), config, workspace);
        URI _xifexpression = null;
        if ((solution instanceof ModelResult)) {
          InputOutput.<String>println("Saving generated solutions");
          final EList<Object> representations = ((ModelResult)solution).getRepresentation();
          int _size = representations.size();
          ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _size, true);
          for (final Integer representationIndex : _doubleDotLessThan) {
            {
              final Object representation = representations.get((representationIndex).intValue());
              final int representationNumber = ((representationIndex).intValue() + 1);
              if ((representation instanceof PartialInterpretation)) {
                StringConcatenation _builder_1 = new StringConcatenation();
                _builder_1.append("solution");
                _builder_1.append(representationNumber);
                _builder_1.append(".partialinterpretation");
                workspace.writeModel(((EObject)representation), _builder_1.toString());
                final PartialInterpretation2Gml partialInterpretation2GML = new PartialInterpretation2Gml();
                final String gml = partialInterpretation2GML.transform(((PartialInterpretation)representation));
                StringConcatenation _builder_2 = new StringConcatenation();
                _builder_2.append("solution");
                _builder_2.append(representationNumber);
                _builder_2.append(".gml");
                workspace.writeText(_builder_2.toString(), gml);
                int _size_1 = ((PartialInterpretation)representation).getNewElements().size();
                boolean _lessThan = (_size_1 < 160);
                if (_lessThan) {
                  if ((representation instanceof PartialInterpretation)) {
                    final Consumer<Type> _function_3 = (Type it) -> {
                      InputOutput.<String>println(it.getName());
                    };
                    ((PartialInterpretation)representation).getProblem().getTypes().forEach(_function_3);
                    final Function1<Type, Boolean> _function_4 = (Type it) -> {
                      String _name_2 = it.getName();
                      return Boolean.valueOf(Objects.equal(_name_2, "Modes3ModelRoot class DefinedPart"));
                    };
                    Type _findFirst = IterableExtensions.<Type>findFirst(((PartialInterpretation)representation).getProblem().getTypes(), _function_4);
                    final TypeDefinition rootType = ((TypeDefinition) _findFirst);
                    final Function1<PartialComplexTypeInterpretation, Boolean> _function_5 = (PartialComplexTypeInterpretation it) -> {
                      String _name_2 = it.getInterpretationOf().getName();
                      return Boolean.valueOf(Objects.equal(_name_2, "Modes3ModelRoot class"));
                    };
                    final PartialComplexTypeInterpretation rootIntepretation = IterableExtensions.<PartialComplexTypeInterpretation>findFirst(Iterables.<PartialComplexTypeInterpretation>filter(((PartialInterpretation)representation).getPartialtypeinterpratation(), 
                      PartialComplexTypeInterpretation.class), _function_5);
                    rootIntepretation.getElements().removeAll(rootType.getElements());
                    ((PartialInterpretation)representation).getProblem().getElements().removeAll(rootType.getElements());
                    EList<PartialRelationInterpretation> _partialrelationinterpretation = ((PartialInterpretation)representation).getPartialrelationinterpretation();
                    for (final PartialRelationInterpretation relationInterpretation : _partialrelationinterpretation) {
                      final Predicate<RelationLink> _function_6 = (RelationLink link) -> {
                        boolean _xifexpression_1 = false;
                        if ((link instanceof BinaryElementRelationLink)) {
                          _xifexpression_1 = (rootType.getElements().contains(((BinaryElementRelationLink)link).getParam1()) || rootType.getElements().contains(((BinaryElementRelationLink)link).getParam2()));
                        } else {
                          _xifexpression_1 = false;
                        }
                        return _xifexpression_1;
                      };
                      relationInterpretation.getRelationlinks().removeIf(_function_6);
                    }
                    rootType.getElements().clear();
                  }
                  final GraphvizVisualiser visualiser = new GraphvizVisualiser();
                  final PartialInterpretationVisualisation visualisation = visualiser.visualiseConcretization(((PartialInterpretation)representation));
                  StringConcatenation _builder_3 = new StringConcatenation();
                  _builder_3.append("solution");
                  _builder_3.append(representationNumber);
                  _builder_3.append(".png");
                  visualisation.writeToFile(workspace, _builder_3.toString());
                }
              } else {
                StringConcatenation _builder_4 = new StringConcatenation();
                _builder_4.append("solution");
                _builder_4.append(representationNumber);
                _builder_4.append(".txt");
                workspace.writeText(_builder_4.toString(), representation.toString());
              }
            }
          }
        } else {
          URI _xblockexpression_1 = null;
          {
            InputOutput.<String>println("Failed to solver problem");
            final LogicProblem partial = logic.getOutput();
            _xblockexpression_1 = workspace.writeModel(partial, "solution.partialinterpretation");
          }
          _xifexpression = _xblockexpression_1;
        }
        _xblockexpression = _xifexpression;
      }
      return _xblockexpression;
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  public static EcoreMetamodelDescriptor createMetamodelDescriptor() {
    EcoreMetamodelDescriptor _xblockexpression = null;
    {
      final ImmutableList<EClass> eClasses = ImmutableList.<EClass>copyOf(Iterables.<EClass>filter(Modes3Package.eINSTANCE.getEClassifiers(), EClass.class));
      Set<EClass> _emptySet = CollectionLiterals.<EClass>emptySet();
      List<EEnum> _emptyList = CollectionLiterals.<EEnum>emptyList();
      List<EEnumLiteral> _emptyList_1 = CollectionLiterals.<EEnumLiteral>emptyList();
      final Function1<EClass, EList<EReference>> _function = (EClass it) -> {
        return it.getEReferences();
      };
      ImmutableList<EReference> _copyOf = ImmutableList.<EReference>copyOf(IterableExtensions.<EClass, EReference>flatMap(eClasses, _function));
      List<EAttribute> _emptyList_2 = CollectionLiterals.<EAttribute>emptyList();
      _xblockexpression = new EcoreMetamodelDescriptor(eClasses, _emptySet, 
        false, _emptyList, _emptyList_1, _copyOf, _emptyList_2);
    }
    return _xblockexpression;
  }
  
  public static List<EObject> loadInitialModel() {
    Modes3ModelRoot _createModes3ModelRoot = Modes3Factory.eINSTANCE.createModes3ModelRoot();
    return Collections.<EObject>unmodifiableList(CollectionLiterals.<EObject>newArrayList(_createModes3ModelRoot));
  }
  
  public ViatraQuerySetDescriptor loadQueries() {
    ViatraQuerySetDescriptor _xblockexpression = null;
    {
      final ImmutableList.Builder<IQuerySpecification<?>> patternsBuilder = ImmutableList.<IQuerySpecification<?>>builder();
      patternsBuilder.addAll(Modes3Queries.instance().getSpecifications());
      final ImmutableList<IQuerySpecification<?>> patterns = patternsBuilder.build();
      final Function1<IQuerySpecification<?>, Boolean> _function = (IQuerySpecification<?> pattern) -> {
        final Function1<PAnnotation, Boolean> _function_1 = (PAnnotation it) -> {
          String _name = it.getName();
          return Boolean.valueOf(Objects.equal(_name, "Constraint"));
        };
        return Boolean.valueOf(IterableExtensions.<PAnnotation>exists(pattern.getAllAnnotations(), _function_1));
      };
      final ImmutableSet<IQuerySpecification<?>> validationPatterns = ImmutableSet.<IQuerySpecification<?>>copyOf(IterableExtensions.<IQuerySpecification<?>>filter(patterns, _function));
      Map<IQuerySpecification<?>, EStructuralFeature> _emptyMap = CollectionLiterals.<IQuerySpecification<?>, EStructuralFeature>emptyMap();
      _xblockexpression = new ViatraQuerySetDescriptor(patterns, validationPatterns, _emptyMap);
    }
    return _xblockexpression;
  }
  
  public static Object init() {
    Object _xblockexpression = null;
    {
      EMFPatternLanguageStandaloneSetup.doSetup();
      ViatraQueryEngineOptions.setSystemDefaultBackends(ReteBackendFactory.INSTANCE, ReteBackendFactory.INSTANCE, 
        LocalSearchEMFBackendFactory.INSTANCE);
      LogiclanguagePackage.eINSTANCE.getClass();
      LogicproblemPackage.eINSTANCE.getClass();
      PartialinterpretationPackage.eINSTANCE.getClass();
      Ecore2logicannotationsPackage.eINSTANCE.getClass();
      Viatra2LogicAnnotationsPackage.eINSTANCE.getClass();
      Map<String, Object> _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
      XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl();
      _extensionToFactoryMap.put("ecore", _xMIResourceFactoryImpl);
      Map<String, Object> _extensionToFactoryMap_1 = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
      XMIResourceFactoryImpl _xMIResourceFactoryImpl_1 = new XMIResourceFactoryImpl();
      _extensionToFactoryMap_1.put("logicproblem", _xMIResourceFactoryImpl_1);
      Map<String, Object> _extensionToFactoryMap_2 = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
      XMIResourceFactoryImpl _xMIResourceFactoryImpl_2 = new XMIResourceFactoryImpl();
      _xblockexpression = _extensionToFactoryMap_2.put("partialinterpretation", _xMIResourceFactoryImpl_2);
    }
    return _xblockexpression;
  }
  
  public static void main(final String[] args) {
    int _length = args.length;
    boolean _notEquals = (_length != 2);
    if (_notEquals) {
      System.err.println("Usage: <query> <model size>");
    }
    final Modes3ModelGenerator.MonitoringQuery monitoringQuery = Modes3ModelGenerator.MonitoringQuery.valueOf(args[0]);
    final int modelSize = Integer.parseInt(args[1]);
    Modes3ModelGenerator.init();
    final Modes3ModelGenerator generator = new Modes3ModelGenerator(monitoringQuery, modelSize);
    generator.generate();
  }
  
  public Modes3ModelGenerator(final Modes3ModelGenerator.MonitoringQuery monitoringQuery, final int modelSize) {
    super();
    this.monitoringQuery = monitoringQuery;
    this.modelSize = modelSize;
  }
}