package org.litesoft.aokeyhole.persist;

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

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.aokeyhole.objects.support.*;
import org.litesoft.aokeyhole.toolkit.*;
import org.litesoft.core.typeutils.*;

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 = Objects.assertNotNull( "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
    {
        protected final List<String> mCollector;
        protected final String mID;
        protected boolean mDone = false;
        private Doneable mCurrentChild;

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

        protected void LLdone()
        {
            checkCanDone();
            mCurrentChild = null;
            mDone = true;
        }

        protected void checkCanDone()
        {
            if ( mDone )
            {
                throw new IllegalStateException( mID + " already 'done()'!" );
            }
            if ( mCurrentChild != null )
            {
                mCurrentChild.assertDone();
            }
        }

        protected void assertDone()
        {
            if ( !mDone )
            {
                throw new IllegalStateException( mID + " NOT 'done()'!" );
            }
        }

        protected <T extends Doneable> T child( T pChild )
        {
            mCurrentChild = pChild;
            return pChild;
        }

        protected void LLaddProperty( String pDepthDots, String pName, String pValue, String... pAdditionalValues )
        {
            checkCanDone();
            pValue = Strings.deNull( pValue );
            if ( pAdditionalValues != null )
            {
                for ( String zValue : pAdditionalValues )
                {
                    pValue += "|" + Strings.deNull( zValue );
                }
            }
            if ( pValue.length() != 0 )
            {
                mCollector.add( pDepthDots + pName + ":" + pValue );
            }
        }

        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( new LinkedList<String>(), "SubSystemBuilder" );
            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 class LinesObjectBuilder extends Doneable implements ObjectBuilder
    {
        private final String mName;
        private boolean mAnyAttributesAdded = false;

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

        @Override
        public void addProperty( String pName, String pValue, String... pAdditionalValues )
        {
            if ( mAnyAttributesAdded )
            {
                throw new IllegalStateException( "ObjectBuilder does not allow Properties to be added after an Attribute is added!" );
            }
            LLaddProperty( "..", pName, pValue, pAdditionalValues );
        }

        @Override
        public AttributeBuilder createAttributeBuilder( String pType, boolean pVirtual, String pName, String[] pNotes, String[] pAdditionalValues )
        {
            checkCanDone();
            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( Strings.deNull( zValue ) );
                }
            }
            mCollector.add( sb.toString() );
            LLaddNotes( "...", pNotes );
            return child( new LinesAttributeBuilder( mCollector, mName, pName ) );
        }

        @Override
        public void done()
        {
            LLdone();
        }
    }

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

        @Override
        public void addProperty( String pName, String pValue, String... pAdditionalValues )
        {
            LLaddProperty( "...", pName, pValue, pAdditionalValues );
        }

        @Override
        public void done()
        {
            LLdone();
        }
    }

    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 );
        }
    }
}