package org.litesoft.aokeyhole.persist.lines;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.aokeyhole.objects.support.*;
import org.litesoft.aokeyhole.persist.*;
import org.litesoft.aokeyhole.toolkit.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;

import java.io.*;
import java.util.*;

public class SubSystemLinesPersister implements SubSystemPersister {
    public static final String TOO_MANY_DATA_PARTS = "Data Section of this line had too many parts";
    private static final String ATTRIBUTE_VIRTUAL_PREFIX = "Virtual-";
    private static final String NOTES = "Notes";

    private final LinesPersister mLinesPersister;

    public SubSystemLinesPersister( LinesPersister pLinesPersister ) {
        mLinesPersister = Confirm.isNotNull( "LinesPersister", pLinesPersister );
    }

    @Override
    public String getName() {
        return mLinesPersister.getName();
    }

    @Override
    public boolean isReadOnly() {
        return mLinesPersister.isReadOnly();
    }

    @Override
    public SubSystemReader getReader( String pExpectedVersion )
            throws IOException {
        return new LinesSubSystemReader( pExpectedVersion, mLinesPersister.loadLines() );
    }

    @Override
    public SubSystemBuilder getBuilder( String pVersion, String pKeyHoleVersion ) {
        return new LinesSubSystemBuilder( mLinesPersister, pVersion, pKeyHoleVersion );
    }

    private static class LinesSubSystemReader implements SubSystemReader {
        private ToLinesObjectsParseStream mOPS;

        private LinesSubSystemReader( String pExpectedVersion, String[] pLines ) {
            mOPS = new ToLinesObjectsParseStream( pLines );
            if ( mOPS.readLine() ) {
                mOPS.validateDepth( 0 );

                String zType = mOPS.getWhat();

                if ( !"vs".equals( zType ) ) {
                    throw mOPS.error( "First Line not a 'vs' (version) line" );
                }
                String[] zParts = mOPS.parseData( '|' );
                String zActual = zParts[0];
                if ( !pExpectedVersion.equals( zActual ) ) {
                    throw mOPS.error( "File version mismatch, got '" + zActual + "', but expected '" + pExpectedVersion + "'." );
                }
            }
        }

        @Override
        public ObjectReader nextObject() {
            return mOPS.readLine() ? new LinesObjectReader( mOPS ) : null;
        }
    }

    private static class LinesObjectReader implements ObjectReader {
        private final ToLinesObjectsParseStream mOPS;
        private final String mType;
        private final String mName;
        private final String mParent;
        private final String[] mNotes;

        private LinesObjectReader( ToLinesObjectsParseStream pOPS ) {
            mOPS = pOPS;
            mOPS.validateDepth( 0 );
            mType = mOPS.getWhat();
            String[] nameNparent = Strings.expectArray( 2, mOPS.parseData( '|' ) );
            if ( nameNparent == null ) {
                throw mOPS.error( TOO_MANY_DATA_PARTS );
            }
            mName = nameNparent[0];
            mParent = nameNparent[1];
            if ( pOPS.isNextDepth( 2 ) && pOPS.isNextWhat( "Notes" ) ) {
                pOPS.readLine();
                mNotes = mOPS.parseData( '|' );
            } else {
                mNotes = null;
            }
        }

        @Override
        public String getType() {
            return mType;
        }

        @Override
        public String getName() {
            return mName;
        }

        @Override
        public String getParent() {
            return mParent;
        }

        @Override
        public String[] getNotes() {
            return mNotes;
        }

        @Override
        public ParseException unrecognizedType( String pMessage ) {
            return mOPS.error( pMessage );
        }

        @Override
        public PropertyReader nextProperty() {
            return mOPS.isNextDepth( 2 ) ? new LinesPropertyReader( mOPS ) : null; // Properties
        }

        @Override
        public AttributeReader nextAttribute() {
            return mOPS.isNextDepth( 1 ) ? new LinesAttributeReader( mOPS ) : null; // Attributes
        }
    }

    private static class LinesAttributeReader implements AttributeReader {
        private final ToLinesObjectsParseStream mOPS;
        private final boolean mVirtual;
        private final String mType;
        private final String mName;
        private final String[] mAdditionalValues;

        private LinesAttributeReader( ToLinesObjectsParseStream pOPS ) {
            (mOPS = pOPS).readLine();
            String zType = mOPS.getWhat();
            mVirtual = zType.startsWith( ATTRIBUTE_VIRTUAL_PREFIX );
            if ( mVirtual ) {
                zType = zType.substring( ATTRIBUTE_VIRTUAL_PREFIX.length() );
            }
            mType = zType;
            String[] parts = mOPS.parseData( '|' );
            mName = parts[0];
            mAdditionalValues = Strings.everythingFrom( parts, 1 );
        }

        @Override
        public String getType() {
            return mType;
        }

        @Override
        public boolean isVirtual() {
            return mVirtual;
        }

        @Override
        public String getName() {
            return mName;
        }

        @Override
        public String[] getAdditionalValues( Integer pExpected ) {
            if ( pExpected == null ) {
                return mAdditionalValues;
            }
            int zExpected = Integers.assertNonNegative( "Expected", pExpected );
            if ( mAdditionalValues.length > zExpected ) {
                throw mOPS.error( "Expected (" + pExpected + ") Additional Parts (seperated by '|'), but was (" + mAdditionalValues.length + ") Parts" );
            }
            return Strings.expectArray( pExpected, mAdditionalValues );
        }

        @Override
        public ParseException unrecognizedType( String pMessage ) {
            return mOPS.error( pMessage );
        }

        @Override
        public PropertyReader nextProperty() {
            return mOPS.isNextDepth( 3 ) ? new LinesPropertyReader( mOPS ) : null; // Properties
        }
    }

    private static class LinesPropertyReader implements PropertyReader {
        private final String mWhat, mData;

        private LinesPropertyReader( ToLinesObjectsParseStream pOPS ) {
            pOPS.readLine();
            mWhat = pOPS.getWhat();
            mData = pOPS.getData();
        }

        @Override
        public String getWhat() {
            return mWhat;
        }

        @Override
        public String getData() {
            return mData;
        }
    }

    private static class Doneable extends DoneableBuilder {
        protected final List<String> mCollector;

        protected Doneable( String pID, List<String> pCollector ) {
            super( pID );
            mCollector = pCollector;
        }

        protected void LLaddNotes( String pDepthDots, String[] pNotes ) {
            String zNotes = SingleLineNotes.convertLinesToString( pNotes );
            if ( zNotes != null ) {
                mCollector.add( pDepthDots + NOTES + ":" + zNotes );
            }
        }
    }

    private static class LinesSubSystemBuilder extends Doneable implements SubSystemBuilder {
        private final LinesPersister mLinesPersister;

        private LinesSubSystemBuilder( LinesPersister pLinesPersister, String pVersion, String pKeyHoleVersion ) {
            super( SUB_SYSTEM, new LinkedList<String>() );
            mLinesPersister = pLinesPersister;
            mCollector.add( "vs:" + pVersion + "|" + pKeyHoleVersion );
        }

        @Override
        public ObjectBuilder createObjectBuilder( String pType, String pName, String pParentName, String[] pNotes ) {
            checkCanDone();
            mCollector.add( "" );
            mCollector.add( "" );
            StringBuilder sb = new StringBuilder( pType ).append( ':' ).append( pName );
            if ( pParentName != null ) {
                sb.append( '|' ).append( pParentName );
            }
            mCollector.add( sb.toString() );
            LLaddNotes( "..", pNotes );
            return child( new LinesObjectBuilder( mCollector, pName ) );
        }

        @Override
        public SubSystemWriter done() {
            LLdone();
            return new LinesSubSystemWriter( mLinesPersister, mCollector.toArray( new String[mCollector.size()] ) );
        }
    }

    private static abstract class OADoneable extends Doneable implements DoneablePropertyBuilder {
        private final String mPropertyDepthDots;

        protected OADoneable( String pID, List<String> pCollector, String pPropertyDepthDots ) {
            super( pID, pCollector );
            mPropertyDepthDots = pPropertyDepthDots;
        }

        public final void done() {
            LLdone();
        }

        @Override
        public boolean recordAllProperties() {
            return false;
        }

        @Override
        public final void addProperty( String pName, String pValue, String... pAdditionalValues ) {
            checkCanAddProperty( getWhyCantAddProperty() );
            pValue = ConstrainTo.notNull( pValue );
            if ( pAdditionalValues != null ) {
                for ( String zValue : pAdditionalValues ) {
                    pValue += "|" + ConstrainTo.notNull( zValue );
                }
            }
            if ( pValue.length() != 0 ) {
                mCollector.add( mPropertyDepthDots + pName + ":" + pValue );
            }
        }

        abstract protected String getWhyCantAddProperty();
    }

    private static class LinesObjectBuilder extends OADoneable implements ObjectBuilder {
        private final String mName;
        private boolean mAnyAttributesAdded = false;

        private LinesObjectBuilder( List<String> pCollector, String pName ) {
            super( objectID( pName ), pCollector, ".." );
            mName = pName;
        }

        @Override
        protected String getWhyCantAddProperty() {
            return !mAnyAttributesAdded ? null : ATTRIBUTES_ALREADY_ADDED;
        }

        @Override
        public AttributeBuilder createAttributeBuilder( String pType, boolean pVirtual, String pName, String[] pNotes, String[] pAdditionalValues ) {
            checkCanDone();
            mAnyAttributesAdded = true;
            mCollector.add( "" );
            StringBuilder sb = new StringBuilder( "." );
            if ( pVirtual ) {
                sb.append( ATTRIBUTE_VIRTUAL_PREFIX );
            }
            sb.append( pType ).append( ':' ).append( pName );
            if ( pAdditionalValues != null ) {
                for ( String zValue : pAdditionalValues ) {
                    sb.append( '|' ).append( ConstrainTo.notNull( zValue ) );
                }
            }
            mCollector.add( sb.toString() );
            LLaddNotes( "...", pNotes );
            return child( new LinesAttributeBuilder( mCollector, mName, pName ) );
        }
    }

    private static class LinesAttributeBuilder extends OADoneable implements AttributeBuilder {
        private LinesAttributeBuilder( List<String> pCollector, String pObjectName, String pName ) {
            super( attributeID( pObjectName, pName ), pCollector, "..." );
        }

        @Override
        protected String getWhyCantAddProperty() {
            return null;
        }
    }

    private static class LinesSubSystemWriter implements SubSystemWriter {
        private final LinesPersister mLinesPersister;
        private final String[] mLines;

        private LinesSubSystemWriter( LinesPersister pLinesPersister, String[] pLines ) {
            mLinesPersister = pLinesPersister;
            mLines = pLines;
        }

        @Override
        public void write()
                throws IOException {
            mLinesPersister.saveLines( mLines );
        }
    }
}