// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.aokeyhole.toolkit;

import java.awt.*;

public class ObjectAndAttributesWithOneDegreeSeperationGraphicView
        implements ObjectAndAttributesWithOneDegreeSeperationView, ScaledDrawableBoxedTextClickable, View
{
    public static final Color COLOR_BG_OBJECT = new Color( 255, 255, 196 ); // LIGHT_YELLOW
    public static final Color COLOR_BG_ATTRIB_SIMPLE = new Color( 196, 255, 196 ); // MID_GREEN
    public static final Color COLOR_BG_ATTRIB_VIRTUAL = new Color( 220, 255, 220 ); // LIGHT_GREEN

    private BoxedText mPrimeObject;

    private ConnectionSet mConnections = new ConnectionSet();
    private AllBoxedSet mAll = new AllBoxedSet();
    private MainBoxedSet mPrimePlusAttributess;
    private RelatedBoxedSet mRelatedObjects;
    private MultiBoxedSet mLowerObjects;
    private BoxedText mUpperObject = null;

    private View mView = ViewNull.INSTANCE;

    public ObjectAndAttributesWithOneDegreeSeperationGraphicView()
    {
        mPrimeObject = mAll.add( new BoxedText( TYPE_OBJECT_MAIN, COLOR_BG_OBJECT, "" ) );

        mPrimePlusAttributess = new MainBoxedSet( AttributeColorSource.INSTANCE, mPrimeObject );
        mPrimePlusAttributess.setView( this ); // Note Leakage of 'this'

        mRelatedObjects = new RelatedBoxedSet( ObjectColorSource.INSTANCE );
        mRelatedObjects.setView( this ); // Note Leakage of 'this'

        mLowerObjects = new MultiBoxedSet( ObjectColorSource.INSTANCE );
        mLowerObjects.setView( this ); // Note Leakage of 'this'
    }

    public void setView( View pView )
    {
        mView = (pView != null) ? pView : ViewNull.INSTANCE;
    }

    @Override
    public void update()
    {
        mView.update();
    }

    @Override
    public void draw( Graphics pGraphics, Dimension pSize )
    {
        mAll.finish( pGraphics );

        mPrimePlusAttributess.makeSameWidths();
        mRelatedObjects.makeSameWidths();
        mLowerObjects.makeSameWidths();

        int width = pSize.width;
        int height = pSize.height;

        int midX = width / 2;

        height = mLowerObjects.layout( height, midX );

        mPrimePlusAttributess.layout( height, midX, mUpperObject );

        int left = midX / 4;
        int right = width - left;

        mRelatedObjects.layout( height, left, right );

        mConnections.draw( pGraphics );

        drawConnectionToUpperObject( pGraphics );
        drawConnectionsToLowerObjects( pGraphics );

        mAll.draw( pGraphics );
    }

    private void drawConnectionToUpperObject( Graphics pGraphics )
    {
        if ( mUpperObject != null )
        {
            mPrimeObject.drawConnectionCenterToCenter( pGraphics, mUpperObject );
        }
    }

    private void drawConnectionsToLowerObjects( Graphics pGraphics )
    {
        int size = mLowerObjects.size();
        if ( size > 0 )
        {
            BoxedText lastBox = mPrimePlusAttributess.getLastBox();
            if ( lastBox != null )
            {
                BoxedText[] children = mLowerObjects.getBoxes();
                for ( BoxedText child : children )
                {
                    lastBox.drawConnectionCenterToCenter( pGraphics, child );
                }
            }
        }
    }

    @Override
    public void dispose()
    {
    }

    @Override
    public void removeAttribute( int pID )
    {
        if ( mPrimePlusAttributess.remove( pID ) )
        {
            mAll.remove( pID );
            BoxedText related = mConnections.remove( pID );
            if ( related != null )
            {
                mAll.remove( related.getID() );
                mRelatedObjects.remove( related.getID() );
            }
        }
    }

    @Override
    public void addNewAttributeOption()
    {
        mAll.add( mPrimePlusAttributess.addNewAttrib() );
    }

    @Override
    public int addSimpleAttribute( String pAttributeName, boolean pIsVirtual )
    {
        return mAll.add( mPrimePlusAttributess.add( pAttributeName, pIsVirtual ) ).getID();
    }

    @Override
    public int addRelatedAttributeToSelf( String pAttributeName, boolean pIsVirtual )
    {
        BoxedText attrib = mAll.add( mPrimePlusAttributess.add( pAttributeName, pIsVirtual ) );

        mConnections.add( attrib, null );

        return attrib.getID();
    }

    @Override
    public int addRelatedAttribute( String pAttributeName, boolean pIsVirtual, String pObjectName )
    {
        BoxedText attrib = mAll.add( mPrimePlusAttributess.add( pAttributeName, pIsVirtual ) );
        BoxedText object = mAll.add( mRelatedObjects.add( pObjectName, null ) );

        mConnections.add( attrib, object );

        return attrib.getID();
    }

    @Override
    public void changeObjectName( String pNewName )
    {
        mPrimeObject.setName( pNewName );
    }

    @Override
    public boolean changeAttributeName( int pID, String pNewName )
    {
        return mPrimePlusAttributess.changeName( pID, pNewName );
    }

    @Override
    public void setParentName( String pNewName )
    {
        if ( mUpperObject != null )
        {
            if ( pNewName != null )
            {
                mUpperObject.setName( pNewName );
                return;
            }
            int id = mUpperObject.getID();
            mUpperObject = null;
            mAll.remove( id );
            return;
        }
        if ( pNewName != null )
        {
            mUpperObject = new BoxedText( TYPE_OBJECT_RELATED, COLOR_BG_OBJECT, pNewName );
            mAll.add( mUpperObject );
            mUpperObject.setControllingSet( mAll );
        }
    }

    /**
     * Note this is not really a dynamic field, so teardown and rebuild is acceptable
     */
    @Override
    public void setGeneratedRelationsByParentNames( String[] pNames )
    {
        int size = mLowerObjects.size();
        if ( size != 0 )
        {
            int[] ids = new int[size];
            BoxedText[] boxes = mLowerObjects.getBoxes();
            for ( int i = 0; i < boxes.length; i++ )
            {
                ids[i] = boxes[i].getID();
            }
            for ( int id : ids )
            {
                mLowerObjects.remove( id );
                mAll.remove( id );
            }
        }
        for ( String zName : pNames )
        {
            mAll.add( mLowerObjects.add( zName, null ) );
        }
    }

    @Override
    public BoxedText getClickedOn( Point pAt )
    {
        return mAll.getClickedOn( pAt );
    }

    // Supporting Classes... ==========================================================================================

    private static class ConnectionSet
    {
        private Connection[] mConnections = Connection.EMPTY_ARRAY;

        public void draw( Graphics pGraphics )
        {
            for ( Connection connection : mConnections )
            {
                connection.draw( pGraphics );
            }
        }

        public void add( BoxedText pFrom, BoxedText pTo )
        {
            mConnections = append( mConnections, new Connection( pFrom, pTo ) );
        }

        private static Connection[] append( Connection[] pOrig, Connection pNew )
        {
            if ( pNew == null )
            {
                return pOrig;
            }
            Connection[] rv = new Connection[pOrig.length + 1];
            rv[0] = pNew;
            System.arraycopy( pOrig, 0, rv, 1, pOrig.length );
            return rv;
        }

        public BoxedText remove( int pID )
        {
            for ( int i = 0; i < mConnections.length; i++ )
            {
                Connection connection = mConnections[i];
                if ( connection.mFrom.getID() == pID )
                {
                    innerRemove( i );
                    return connection.mTo;
                }
                if ( (connection.mTo != null) && (connection.mTo.getID() == pID) )
                {
                    innerRemove( i );
                    return connection.mFrom;
                }
            }
            return null;
        }

        private void innerRemove( int pIndex )
        {
            Connection[] shrunk = new Connection[mConnections.length - 1];
            if ( pIndex != 0 ) // Not First
            {
                System.arraycopy( mConnections, 0, shrunk, 0, pIndex );
            }
            if ( pIndex != mConnections.length - 1 ) // Not Last
            {
                System.arraycopy( mConnections, pIndex + 1, shrunk, pIndex, shrunk.length - pIndex );
            }
            mConnections = shrunk;
        }

        private static class Connection
        {
            public static final Connection[] EMPTY_ARRAY = new Connection[0];

            private BoxedText mFrom, mTo;

            public Connection( BoxedText pFrom, BoxedText pTo )
            {
                mFrom = pFrom;
                mTo = pTo;
            }

            public void draw( Graphics pGraphics )
            {
                mFrom.drawConnection( pGraphics, mTo );
            }
        }
    }

    private static class ObjectColorSource implements ColorSource
    {
        public static final ColorSource INSTANCE = new ObjectColorSource();

        @Override
        public Color getColor( Object pParameter )
        {
            return COLOR_BG_OBJECT;
        }
    }

    private static class AttributeColorSource implements ColorSource
    {
        public static final ColorSource INSTANCE = new AttributeColorSource();

        @Override
        public Color getColor( Object pParameter )
        {
            return Boolean.TRUE.equals( pParameter ) ? COLOR_BG_ATTRIB_VIRTUAL : COLOR_BG_ATTRIB_SIMPLE;
        }
    }

    private static class AllBoxedSet extends BoxedSet
    {
        private boolean mUnfinished = false;

        public void finish( Graphics pGraphics )
        {
            if ( mUnfinished )
            {
                for ( BoxedText box : mBoxes )
                {
                    box.finish( pGraphics );
                }
            }
        }

        @Override
        public void setChanged()
        {
            mUnfinished = true;
            super.setChanged();
        }

        public BoxedText getClickedOn( Point pAt )
        {
            for ( int i = mBoxes.length; --i >= 0; ) // Note reverse order due to Overlaying
            {
                BoxedText box = mBoxes[i];
                if ( box.isClickedOn( pAt ) )
                {
                    return box;
                }
            }
            return null;
        }
    }

    private abstract static class ColorSourcedBoxedSet extends BoxedSet
    {
        private int mType;
        private ColorSource mColorSource;

        public ColorSourcedBoxedSet( int pType, ColorSource pColorSource )
        {
            mType = pType;
            mColorSource = pColorSource;
        }

        public BoxedText add( String pName, Object pParameter )
        {
            return add( new BoxedText( mType, mColorSource.getColor( pParameter ), pName ) );
        }
    }

    private static class SameWidthBoxedSet extends ColorSourcedBoxedSet
    {
        private boolean mWidthsProbablyNotSame = false;

        public SameWidthBoxedSet( int pType, ColorSource pColorSource )
        {
            super( pType, pColorSource );
        }

        public void makeSameWidths()
        {
            if ( mWidthsProbablyNotSame )
            {
                mWidthsProbablyNotSame = false;
                int maxBoxWidth = 0;
                for ( BoxedText box : mBoxes )
                {
                    maxBoxWidth = Math.max( maxBoxWidth, box.getBoxWidth() );
                }
                for ( BoxedText box : mBoxes )
                {
                    box.setBoxWidth( maxBoxWidth );
                }
            }
        }

        @Override
        public BoxedText add( BoxedText pNew )
        {
            BoxedText boxedText = super.add( pNew );
            boxedText.setControllingSet( this );
            return boxedText;
        }

        @Override
        public void setChanged()
        {
            mWidthsProbablyNotSame = (mBoxes.length > 1);
            super.setChanged();
        }
    }

    private static class MainBoxedSet extends SameWidthBoxedSet
    {
        private BoxedText mNewAttrib = null;

        public MainBoxedSet( ColorSource pColorSource, BoxedText pPrime )
        {
            super( TYPE_ATTRIB_EXISTING, pColorSource );

            add( pPrime );
        }

        @Override
        public void dispose()
        {
            mNewAttrib = null;
            super.dispose();
        }

        public BoxedText addNewAttrib()
        {
            if ( mNewAttrib != null )
            {
                return null;
            }
            mNewAttrib = add( new BoxedText( TYPE_ATTRIB_NEW, COLOR_BG_ATTRIB_VIRTUAL, "+" ) );
            return mNewAttrib;
        }

        @Override
        protected void innerAdd( BoxedText pNew )
        {
            super.innerAdd( pNew ); // Add to end
            if ( mNewAttrib != null )
            {
                // Swap Ends so that the end one is "New Attribute" option
                BoxedText last = mBoxes[mBoxes.length - 1];
                mBoxes[mBoxes.length - 1] = mBoxes[mBoxes.length - 2];
                mBoxes[mBoxes.length - 2] = last;
            }
        }

        public void layout( int pHeight, int pAlignOnX, BoxedText pUpperObject )
        {
            int boxHeight = mBoxes[0].getBoxHeight();
            int baseTop = 0;

            if ( pUpperObject != null )
            {
                pUpperObject.setAtXY( pAlignOnX, boxHeight );
                baseTop = boxHeight + (boxHeight / 2);
            }

            int atY, deltaY;

            int overallAvail = pHeight - (baseTop + boxHeight); // remove baseTop + spacing
            int overallOptimalSize = size() * boxHeight;

            if ( overallAvail < overallOptimalSize )
            {
                atY = baseTop + boxHeight;  // spacer + centering
                deltaY = overallAvail / size();
            }
            else
            {
                atY = baseTop + ((overallAvail - overallOptimalSize) / 3) + boxHeight; // spacer + centering
                deltaY = boxHeight;
            }

            for ( BoxedText box : mBoxes )
            {
                box.setAtXY( pAlignOnX, atY );
                atY += deltaY;
            }
        }

        public boolean changeName( int pID, String pNewName )
        {
            for ( BoxedText box : mBoxes )
            {
                if ( box.getID() == pID )
                {
                    box.setName( pNewName );
                    return true;
                }
            }
            return false;
        }
    }

    private static class RelatedBoxedSet extends SameWidthBoxedSet
    {
        public RelatedBoxedSet( ColorSource pColorSource )
        {
            super( TYPE_OBJECT_RELATED, pColorSource );
        }

        public void layout( int pHeight, int pAlignOnLeftX, int pAlignOnRightX )
        {
            int half = (size() + 1) / 2;

            setBoxes( 0, half, pAlignOnLeftX, pHeight );
            setBoxes( 1, size() - half, pAlignOnRightX, pHeight );
        }

        private void setBoxes( int pFrom, int pCount, int pAtX, int pYspace )
        {
            if ( pCount > 0 )
            {
                int deltaY = pYspace / (pCount + 1);
                for ( int atY = 0; pFrom < mBoxes.length; pFrom += 2 )
                {
                    mBoxes[pFrom].setAtXY( pAtX, atY += deltaY );
                }
            }
        }
    }

    private static class MultiBoxedSet extends SameWidthBoxedSet
    {
        public MultiBoxedSet( ColorSource pColorSource )
        {
            super( TYPE_OBJECT_RELATED, pColorSource );
        }

        public int layout( int pHeight, int pAlignOnX )
        {
            if ( mBoxes.length == 0 )
            {
                return pHeight;
            }
            int boxWidth = mBoxes[0].getBoxWidth();
            int boxHeight = mBoxes[0].getBoxHeight();
            int atY = pHeight - boxHeight;

            int spacer = boxHeight / 2;
            int deltaX = boxWidth + spacer;

            int atX = pAlignOnX;
            if ( (mBoxes.length & 1) == 0 ) // even
            {
                atX -= deltaX / 2;
            }
            for ( int i = mBoxes.length; i > 2; i -= 2 )
            {
                atX -= deltaX;
            }

            for ( BoxedText box : mBoxes )
            {
                box.setAtXY( atX, atY );
                atX += deltaX;
            }

            return atY - (boxHeight / 2);
        }
    }
}