Как сделать Java код проще и нагляднее

final class MetaDataMapper
{
    /**
        Огромное количество констант
    **/

    MetaDataMapper( VirtualFile file, 1СDocument sdk, 1СDocument target, @Nullable Element root )
    {
        this.file = file;
        this.sdk = sdk;
        this.target = target;
        this.root = root;
        resolver = new OneCv8ClassResolver( target );
        sourceFile = new SourceFileStub( file.getAbsoluteName().substring( 1 ), null );
        dummyDeclareStatement = DeclareStatementModifier.dummy( file );
    }

    private final VirtualFile file;
    private final SourceFileStub sourceFile;
    private final 1СDocument sdk;
    private final Element root;
    private final 1СDocument target;
    private final OneCv8ClassResolver resolver;
    private final DeclareStatementModifier dummyDeclareStatement;
    private ClassBuilder classBuilder;
    private List<ClassBuilder> transformationClasses;

    void mapElement()
    {
        if( file.getName().startsWith( "Subsystem." )
                || file.getName().startsWith( "WSReference." )
                || file.getName().startsWith( "CommonAttribute." ) )
            return;

        if( root.getTagName().equalsIgnoreCase( "Configuration" ) )
        {
            target.newClass( "System.Конфигурация.ЭтаКонфигурация" )
                    .parent( TYPE_CONFIGURATION )
                    .superClass( TYPE_CONFIGURATION.classReference() )
                    .declareStatement( asStatement( root ) )
                    .customData( ATTR_UUID, root.getAttribute( ATTR_UUID ) )
                    .build();
            return;
        }

        Element properties = XmlUtils.getSingleElementOrDie( root, TAG_PROPERTIES );
        Element innerInfo = XmlUtils.getSingleElementOrNull( root, TAG_INNER_INFO );
        Element internalInfo = XmlUtils.getSingleElementOrNull( root, TAG_INTERNAL_INFO );
        Element childObjects = XmlUtils.getSingleElementOrNull( root, TAG_CHILD_OBJECTS );
        Element standardAttributes = XmlUtils.getSingleElementOrNull( properties, TAG_STANDARD_ATTRIBUTES );

        resolveThisClass();
        transformationClasses = new ArrayList<>();
        if( innerInfo != null || internalInfo != null )
            new ClassTransformer( innerInfo, internalInfo ).doTransform();

        if( childObjects != null )
            readChildren( childObjects, standardAttributes, classBuilder, transformationClasses );

        if( properties != null && root.getTagName().equalsIgnoreCase( "Document" ) )
            registerDocumentSpecials( properties );

        notifyComplete();
    }

    void mapFormElement()
    {
        if( !root.getTagName().equalsIgnoreCase( "Form" ) )
            throw new IllegalStateException();

        resolveThisClass();
        FormAttributeReader attributeReader = new FormAttributeReader( classBuilder, transformationClasses );
        readFormAttrs( attributeReader, TAG_ATTRIBUTES, TAG_ATTRIBUTE );
        readFormAttrs( attributeReader, TAG_PARAMETERS, TAG_PARAMETER );

        Element elements = XmlUtils.getSingleElementOrNull( root, TAG_ELEMENTS );
        if( elements != null )
            new FormElementsReader( elements ).read();

        Element commands = XmlUtils.getSingleElementOrNull( root, "Commands" );
        if( commands != null )
            new FormCommandsReader( XmlUtils.getChildren( commands, "Command" ), asStatement( commands ) ).read();
        notifyComplete();
    }

    void mapPredefined()
    {
        if( !root.getTagName().equalsIgnoreCase( "predefinedData" ) )
            throw new IllegalStateException();

        resolveThisClass();

        for( Element item : XmlUtils.getChildren( root, "item" ) )
        {
            String name = XmlUtils.getTextContentOrDie( item, "name" );
            Element codeElement = XmlUtils.getSingleElementOrNull( item, "code" );
            String attrType = null;
            if( codeElement != null )
                attrType = codeElement.getAttribute( "xsi:type" );

            1CType type = StringUtils.isBlank( attrType )
                    ? getFieldType( item, "type" )
                    : resolver.resolveType( Collections.singletonList( attrType ) );

            classBuilder.field( name ).type( type ).declareStatement( asStatement( item ) ).build();
        }
        notifyComplete();
    }

    void mapTxtFile()
    {
        1CClassReference reference = resolver.buildClassStructure( file.getName() );
        if( reference == null )
            throw new IllegalStateException( "Unable to resolve class: " + file );

        classBuilder = target
                .editClass( reference )
                .modifier( dummyDeclareStatement );

        transformationClasses = new ArrayList<>();
        new PlainClassTransformer().doTransform();
        notifyComplete();
    }

    private void resolveThisClass()
    {
        1CClassReference reference = resolver.buildClassStructure( file.getName() );
        if( reference == null )
            throw new IllegalStateException( "Unable to resolve class: " + file.getName() );

        classBuilder = target.editClass( reference );

        Element properties = XmlUtils.getSingleElementOrNull( root, TAG_PROPERTIES );
        if( !root.getTagName().equals( "predefinedData" ) )
            classBuilder.declareStatement( asStatement( root ) )
                    .customData( ATTR_UUID, root.getAttribute( ATTR_UUID ) );

        String tagName = root.getTagName();
        if( FORMS.contains( tagName.toLowerCase() ) && isManagedForm() )
        {
            classBuilder.parent( TYPE_MANAGED_FORM )
                    .modifier( Modifiers.ENFORCE_PARENT_CLASS );
        }
        else if( properties != null && tagName.equalsIgnoreCase( "Constant" ) )
            registerConstantValueField( properties );
        else if( properties != null && tagName.equalsIgnoreCase( "SessionParameter" ) )
            registerSessionParameter( properties );
    }

    private void notifyComplete()
    {
        classBuilder.build();
        if( transformationClasses != null )
            transformationClasses.forEach( ClassBuilder:: build );
    }

    private void registerDocumentSpecials( Node properties )
    {
        ClassBuilder newRegisterRecordsCollection = createRecordsCollection();
        createSpecialFields( newRegisterRecordsCollection );

        Element registerRecords = XmlUtils.getSingleElementOrNull( properties, "RegisterRecords" );
        if( registerRecords != null )
            for( Element element : XmlUtils.getChildren( registerRecords, "xr:item" ) )
                registerDocumentSpecialMember( newRegisterRecordsCollection, element );

        newRegisterRecordsCollection.build();
    }

    private void registerDocumentSpecialMember( ClassBuilder newRegisterRecordsCollection, Node element )
    {
        String typeName = element.getTextContent();
        1CClassReference reference = resolver.buildClassStructure( typeName );
        1CClass aClass = reference == null ? null : target.getClassOrNull( reference );
        if( aClass == null )
            log.warn( "Failed to resolve: " + typeName );
        else
        {
            String name = aClass.getName();
            String memberTypeName =
                    OneCv8Types.NAMESPACE + '.'
                            + aClass.getParentClass().classReference().getName() + "НаборЗаписей." + name;

            1CType memberType = OneCv8Types.parse( memberTypeName );
            newRegisterRecordsCollection
                    .field( name )
                    .type( memberType )
                    .declareStatement( asStatement( element ) )
                    .buildField();
        }
    }

    private void createSpecialFields( ClassBuilder newRegisterRecordsCollection )
    {
        1CType type = newRegisterRecordsCollection.getReference().to1CType();
        for( ClassBuilder aClass : transformationClasses )
            if( REF_DOCUMENT_OBJECT.equals( aClass.getSuperClass() ) )
                aClass
                        .field( "Движения" )
                        .type( type )
                        .declareStatement( aClass.getDeclareStatement() )
                        .build();
    }

    @NotNull
    private ClassBuilder createRecordsCollection()
    {
        1CClassReference newRegisterRecordsCollectionReference =
                OneCv8Language.reference( REF_RECORDS_COLLECTION.getFullName() + '.' + classBuilder.getReference().getName() );

        if( target.getClassOrNull( newRegisterRecordsCollectionReference ) == null )
            return target.newClass( newRegisterRecordsCollectionReference )
                    .superClass( REF_RECORDS_COLLECTION )
                    .parent( REF_RECORDS_COLLECTION.to1CType() );

        return target.editClass( newRegisterRecordsCollectionReference );
    }

    private void registerSessionParameter( Node properties )
    {
        ClassBuilder paramClassBuilder = target.editClass( REF_SESSION_PARAMETERS );
        String name = Utils.getObjectName( properties );
        1CType type = getFieldType( properties, TAG_TYPE );
        paramClassBuilder
                .field( name ).type( type ).declareStatement( asStatement( root ) ).build()
                .build();
    }

    private void registerConstantValueField( Node properties )
    {
        1CType fieldType = getFieldType( properties, TAG_TYPE );
        classBuilder.field( "Значение" )
                .type( fieldType )
                .declareStatement( asStatement( root ) )
                .build();
    }

    private boolean isManagedForm()
    {
        Element properties = XmlUtils.getSingleElementOrNull( root, TAG_PROPERTIES );
        String formType = properties == null ? null : XmlUtils.getTextContentOrNull( properties, "FormType" );
        return "managed".equalsIgnoreCase( formType );
    }

    private void readFormAttrs( FormAttributeReader attributeReader, String tagName, String childTagName )
    {
        Element attributes = XmlUtils.getSingleElementOrNull( root, tagName );
        if( attributes != null )
            for( Element element : XmlUtils.getChildren( attributes, childTagName ) )
                attributeReader.read( element );
    }

    private void readChildren( Node childObjects, @Nullable Node standardAttributes, ClassBuilder primaryClass, List<ClassBuilder> secondaryClasses )
    {
        AbstractChildReader classFieldReader = new ClassFieldReader( primaryClass, secondaryClasses );
        AbstractChildReader tabularSectionReader = new TabularSectionReader( primaryClass, secondaryClasses );
        AbstractChildReader commandReader = new CommandReader( primaryClass, secondaryClasses );

        Collection<Element> children = XmlUtils.getChildren( childObjects );
        for( Element child : children )
        {
            String tagName = child.getTagName();
            if( ALLOWED_CLASS_FIELDS.contains( tagName.toLowerCase() ) )
                classFieldReader.read( child );
            else if( TAG_TABULAR_SECTION.equalsIgnoreCase( tagName ) )
                tabularSectionReader.read( child );
            else if( TAG_COMMAND.equalsIgnoreCase( tagName ) )
                commandReader.read( child );
            else if( !SKIPPED_CLASS_FIELDS.contains( tagName.toLowerCase() ) )
                log.error( "Skipping child object of unknown type - " + tagName );
        }

        if( standardAttributes != null )
        {
            Collection<Element> attributes = XmlUtils.getChildren( standardAttributes );
            StandardAttributeReader reader = new StandardAttributeReader( primaryClass, secondaryClasses );
            attributes.forEach( reader:: readAttribute );
        }
    }

    private 1CType getFieldType( Node properties, String typeTagName )

    private IStatement asStatement( Node node )

    private final class FormElementsReader
    {
        private final Element elements;
        private final ClassBuilder elementsSubClass;
        private final 1CClassReference parentClassReference;
        private final Deque<1CClassReference> eventTypeSource = new LinkedList<>();

        void read()

        void read( Node elementsNode )
    }

    private final class FormCommandsReader
    {
        private final List<Element> commands;
        private final ClassBuilder formCommands;

        void read()

    }

    private final class FormAttributeReader extends AbstractChildReader
    {
        @Override
        void read( Element element )
    }

    private final class SubTableAttributeReader extends AbstractChildReader
    {
        private final String className;
        private final 1CType parentClass;
        private final 1CClassReference pathToColumns;

        @Override
        void read( Element element )
    }

    private final class StandardAttributeReader
    {
        private static final String CUSTOM_DATA_KEY_ALIAS = "alias";

        private final ClassBuilder primaryClass;
        private final List<ClassBuilder> secondaryClasses;

        void readAttribute( Element attribute )
    }

    private static final class AttributeTemplate
    {
        private String name;
        private 1CType type;
        private final Collection<Modifier> modifiers = new HashSet<>();

        void addModifier( Modifier modifier )

        void setType( 1CType type )

        public void setName( String name )

        String getName()

        1CType getType()

        Collection<Modifier> getModifiers()
    }

    private abstract class AbstractChildReader
    {
        private final ClassBuilder primaryClass;
        private final Collection<ClassBuilder> secondaryClasses;

        ClassBuilder getPrimaryClass()

        Collection<ClassBuilder> getSecondaryClasses()

        1CType getXmlFieldType( Node properties, boolean useClassType, String typeTagName )

        abstract void read( Element element );

        void forEachClass( Consumer<ClassBuilder> callback )
    }

    private final class ClassFieldReader extends AbstractChildReader
    {
        @Override
        void read( Element element )
    }

    private final class TabularSectionReader extends AbstractChildReader
    {
        @Override
        void read( Element element )
    }

    private final class CommandReader extends AbstractChildReader
    {
        @Override
        void read( Element element )
    }

    private final class ParentMembersReplacer
    {
        private final ClassBuilder currentClass;
        private final Collection<1CClassReference> typesToReplace;
        private final 1CClass parent;
        private boolean typeReplaced;

        void copyMembersFromParent()

    }

    private class PlainClassTransformer
    {
        private ClassBuilder current;

        void doTransform()

        void doPrimaryClassTransformations()

        void produceType( String name, @Nullable String uuid, Modifier declareStatementModifier )

        void registerField( 1CClassReference classReference )

        void registerSubClass( String subClassParentName )
    }

    private final class ClassTransformer extends PlainClassTransformer
    {
        private final Element innerInfo;
        private final Element internalInfo;

        @Override
        void doTransform()
    }
}