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

import org.litesoft.bo.attributes.*;
import org.litesoft.commonfoundation.csv.*;
import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.db.*;
import org.litesoft.logger.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.nonpublic.*;
import org.litesoft.orsup.otherattributeaccessors.*;

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

public class DB_Export
{
    static Logger sLogger = LoggerFactory.getLogger( DB_Export.class );

    public static final char NEW_LINE_CHAR = '\n';

    /**
     * Exports current database to given file in csv format
     */
    public static void exportCSV( String fileName )
            throws IOException
    {
        FileWriter zWriter = new FileWriter( fileName );
        exportCSV( zWriter );
        zWriter.flush();
        zWriter.close();
    }

    /**
     * Exports current database to given file in csv format
     */
    public static void exportCSV( Writer pWriter )
            throws IOException
    {
        DataStore ds = DataStoreLocator.get();

        UnfilteringFinder zFinder = ds.getUnfilteredFinder();

        MetaDataStore zMetaDataStore = ds.getMetaDataStore();
        if ( !(zMetaDataStore instanceof MetaDataRegistry) )
        {
            throw new Error( "MetaDataStore not a MetaDataRegistry" );
        }
        MetaDataForPO[] zPO_MDs = reverseAndFilter( ((MetaDataRegistry) zMetaDataStore).getInReducingDependancyOrderAllMetaDataForPO() );

        for ( MetaDataForPO md : zPO_MDs )
        {
            exportByType( pWriter, zFinder, md );
        }
    }

    public static void printObjects( Writer pWriter, POQueryIterator pPOs )
            throws IOException
    {
        if ( pPOs.hasNext() )
        {
            PersistentObject zPO = pPOs.next();
            AttributeAccessorSCD[] zSCDs = zPO.getMetaDataForPO().getAccessorSCDs(); // PersistingAccessorSCDs();
            printObject( pWriter, zPO, zSCDs );
            while ( pPOs.hasNext() )
            {
                printObject( pWriter, pPOs.next(), zSCDs );
            }
        }
    }

    private static void exportByType( Writer pWriter, UnfilteringFinder pFinder, MetaDataForPO md )
            throws IOException
    {
        POQueryIterator zPOs;
        try
        {
            zPOs = pFinder.findAllCursored( md.getPOregistrationName(), null );
        }
        catch ( DBException e )
        {
            pWriter.write( "# *** Error *** " + md.getIdentifierName() + ": " + e.getMessage() + NEW_LINE_CHAR );
            sLogger.error.log( e, md.getIdentifierName() );
            return;
        }
        try
        {
            if ( zPOs.hasNext() )
            {
                pWriter.write( "# " + md.getIdentifierName() + NEW_LINE_CHAR );
                printObjects( pWriter, zPOs );
                pWriter.write( NEW_LINE_CHAR );
            }
        }
        finally
        {
            zPOs.releaseResources();
        }
    }

    private static MetaDataForPO[] reverseAndFilter( MetaDataForPO[] pPOmds )
    {
        if ( Objects.isNullOrEmpty( pPOmds ) )
        {
            return pPOmds;
        }
        List<MetaDataForPO> zPOmds = new ArrayList<MetaDataForPO>( pPOmds.length );
        for ( int zSrcNdx = pPOmds.length; --zSrcNdx >= 0; )
        {
            MetaDataForPO md = pPOmds[zSrcNdx];
            if ( md.isImportable() )
            {
                zPOmds.add( md );
            }
        }
        return zPOmds.toArray( new MetaDataForPO[zPOmds.size()] );
    }

    private static void printObject( Writer pWriter, PersistentObject<?> pPO, AttributeAccessorSCD... pSCDs )
            throws IOException
    {
        Vector<String> unencodedData = new Vector<String>();
        unencodedData.add( new PersistentObjectURL( pPO.getObjectName(), pPO.getPersistentObjectUniqueKey() ).toString() );
        for ( SupplimentedSCD attr : pSCDs )
        {
            if ( isExportable( attr ) )
            {
                String attributeName = attr.getName();
                Object value = pPO.getAttributeValue( attributeName );
                if ( value != null )
                {
                    if ( SupplimentedSCD.Form.ToOne.equals( attr.getForm() ) )
                    {
                        if ( attr instanceof AttributeAccessorSCDtoOneVariable )
                        {
                            AttributeAccessorSCDtoOneVariable zVariableOne = (AttributeAccessorSCDtoOneVariable) attr;
                            value = getVariableToOneDBvalue( pPO, zVariableOne );
                        }
                        else
                        {
                            PersistentObject zThem = (PersistentObject) value;
                            value = new PersistentObjectURL( zThem.getObjectName(), zThem.getPersistentObjectUniqueKey() );
                        }
                    }
                    if ( value != null )
                    {
                        String strValue = value.toString().trim();
                        if ( strValue.length() != 0 )
                        {
                            unencodedData.add( attributeName + "=" + strValue );
                        }
                    }
                }
            }
        }
        String encodedData = new CsvSupport().encode( unencodedData.toArray( new String[unencodedData.size()] ) );

        pWriter.append( encodedData );
        pWriter.append( NEW_LINE_CHAR );
        pWriter.flush();
    }

    private static boolean isExportable( SupplimentedSCD attr )
    {
        return !Mutability.RO.equals( attr.getMutability() ) && //
               !(attr instanceof NonImportableFeature) && //
               !AttributeMetaData.Type.Password.equals( attr.getAMD().getType() ) && //
               !SupplimentedSCD.Form.ToMany.equals( attr.getForm() );
    }

    @SuppressWarnings({"unchecked"})
    private static Object getVariableToOneDBvalue( PersistentObject<?> pPO, AttributeAccessorSCDtoOneVariable pVariableOne )
    {
        return pVariableOne.db_getValueOnPO( pPO );
    }
}