// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.util.tempdirimageaccessor;

import java.io.*;

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;

public class FileNameParts
{
    private static final char SEP = '-';
    private static final String WIDTH_INDICATOR = "w";
    private static final String HEIGHT_INDICATOR = "h";

    private String mPrefix;
    private String mEncodedExtraInfo;
    private Integer mImageWidth;
    private Integer mImageHeight;
    private String mUniquingPortion;
    private String mImageEncoding;
    private static final char EXT_SEP = '.';

    public String createFileNamePrefix()
    {
        StringBuilder sb = new StringBuilder();
        sb.append( mPrefix ).append( SEP ).append( mEncodedExtraInfo );
        if ( mImageWidth != null )
        {
            sb.append( SEP ).append( WIDTH_INDICATOR ).append( mImageWidth );
        }
        if ( mImageHeight != null )
        {
            sb.append( SEP ).append( HEIGHT_INDICATOR ).append( mImageHeight );
        }
        return sb.append( SEP ).toString();
        // UniquingPortion
        // .
        // ImageEncoding
    }

    public static String delineateUniquingPortion( String pUniquingPortion )
    {
        return "" + SEP + pUniquingPortion + EXT_SEP;
    }

    public String createFileNameExt()
    {
        return "" + EXT_SEP + mImageEncoding;
    }

    public static FileNameParts createFromFileName( String pOpaqueStoredImageKey_ie_FileName )
    {
        //noinspection UnnecessaryLocalVariable
        FileNameParts rv = new FileNameParts();
        int at = pOpaqueStoredImageKey_ie_FileName.indexOf( EXT_SEP );
        if ( at == -1 )
        {
            throw new IllegalStateException(
                    "Bad File Name, No '.' in: " + pOpaqueStoredImageKey_ie_FileName );
        }
        rv.setImageEncoding( pOpaqueStoredImageKey_ie_FileName.substring( at + 1 ) );
        String[] parts = Strings.parseChar( pOpaqueStoredImageKey_ie_FileName.substring( 0, at ), SEP );
        for ( int i = 2; i < parts.length; i++ )
        {
            if ( parts[i].length() == 0 )
            {
                throw new IllegalStateException(
                        "Bad File Name, Empty Part[i]: " + pOpaqueStoredImageKey_ie_FileName );
            }
        }
        // part[0] = Prefix
        // part[1] = EncodedExtraInfo
        // part[?2?] = wWidth
        // part[?2/3?] = hHeight
        // part[2/3/4] = UniquingPortion
        switch ( parts.length )
        {
            case 0:
            case 1:
            case 2:
                throw new IllegalStateException(
                        "Bad File Name, Insufficient Parts: " + pOpaqueStoredImageKey_ie_FileName );
            case 3:
                rv.first2parts( parts );
                rv.mUniquingPortion = parts[2];
                break;
            case 4:
                rv.first2parts( parts );
                if ( parts[2].startsWith( WIDTH_INDICATOR ) )
                {
                    rv.setImageWidth( parseDimension( "Width", WIDTH_INDICATOR, WIDTH_INDICATOR, parts, 2,
                                                      pOpaqueStoredImageKey_ie_FileName ) );
                }
                else
                {
                    rv.setImageHeight( parseDimension( "Height", WIDTH_INDICATOR + "/" + HEIGHT_INDICATOR,
                                                       HEIGHT_INDICATOR, parts, 2,
                                                       pOpaqueStoredImageKey_ie_FileName ) );
                }

                rv.mUniquingPortion = parts[3];
                break;
            case 5:
                rv.first2parts( parts );
                rv.setImageWidth( parseDimension( "Width", WIDTH_INDICATOR, WIDTH_INDICATOR, parts, 2,
                                                  pOpaqueStoredImageKey_ie_FileName ) );
                rv.setImageHeight( parseDimension( "Height", HEIGHT_INDICATOR, HEIGHT_INDICATOR, parts, 3,
                                                   pOpaqueStoredImageKey_ie_FileName ) );
                rv.mUniquingPortion = parts[4];
                break;
            default:
                throw new IllegalStateException(
                        "Bad File Name, too Many Parts: " + pOpaqueStoredImageKey_ie_FileName );
        }
        return rv;
    }

    private static Integer parseDimension( String pWhat, String pMustStartWith, String pExpectedIndicator,
                                           String[] pParts, int i, String pFullFileName )
    {
        String part = pParts[i];
        if ( !part.startsWith( pExpectedIndicator ) )
        {
            throw new IllegalStateException( "Bad File Name, Part[" + i + "] did not start with " +
                                             pMustStartWith + ": " + pFullFileName );
        }
        part = part.substring( 1 ).trim();
        if ( part.length() != 0 )
        {
            try
            {
                return Integer.parseInt( part );
            }
            catch ( NumberFormatException e )
            {
                // fall thru
            }
        }
        throw new IllegalStateException(
                "Bad File Name, Part[" + i + "] was not a valid " + pWhat + ": " + pFullFileName );
    }

    private void first2parts( String[] pParts )
    {
        setPrefix( pParts[0] );
        mEncodedExtraInfo = pParts[1];
    }

    private FileNameParts()
    {
    }

    private FileNameParts( String pPrefix, String pExtraInfo, Integer pImageWidth, Integer pImageHeight,
                           String pImageEncoding )
    {
        setPrefix( pPrefix );
        mEncodedExtraInfo = encodeExtraInfo( pExtraInfo );
        setImageWidth( pImageWidth );
        setImageHeight( pImageHeight );
        setImageEncoding( pImageEncoding );
    }

    public FileNameParts( String pPrefix, String pExtraInfo, int pImageWidth, int pImageHeight,
                          String pImageEncoding )
    {
        this( pPrefix, pExtraInfo, Integer.valueOf( pImageWidth ), Integer.valueOf( pImageHeight ),
              pImageEncoding );
    }

    public FileNameParts( String pPrefix, String pExtraInfo )
    {
        this( pPrefix, pExtraInfo, null, null, null );
    }

    public String getPrefix()
    {
        return mPrefix;
    }

    /**
     * @param pPrefix Wil be used as Front of file name
     *
     * @throws IllegalArgumentException if not updateable or not AlphaNumeric (and Underscore) or less than 3 characters long
     */
    private void setPrefix( String pPrefix )
    {
        String str = Strings.noEmpty( pPrefix );
        if ( str != null )
        {
            if ( str.length() < 3 )
            {
                throw new IllegalArgumentException( "Prefix '" + str + "', Not at least 3 characters long" );
            }
            for ( int i = 0; i < str.length(); i++ )
            {
                char c = str.charAt( i );
                if ( (c != '_') && !Characters.is7BitAsciiAlpha( c ) && !Characters.isNumeric( c ) )
                {
                    throw new IllegalArgumentException(
                            "Prefix: '" + c + "' Not a 7 Bit Ascii AlphaNumeric or underscore at: " + i );
                }
            }
        }
        mPrefix = str;
    }

    public String getEncodedExtraInfo()
    {
        return mEncodedExtraInfo;
    }

    public Integer getImageWidth()
    {
        return mImageWidth;
    }

    /**
     * @param pWidth non-negative
     *
     * @throws IllegalArgumentException if negative or not updateable
     */
    private void setImageWidth( Integer pWidth )
            throws IllegalArgumentException
    {
        mImageWidth = chkDimensionalSize( "Width", pWidth );
    }

    public Integer getImageHeight()
    {
        return mImageHeight;
    }

    /**
     * @param pHeight non-negative
     *
     * @throws IllegalArgumentException if negative or not updateable
     */
    private void setImageHeight( Integer pHeight )
            throws IllegalArgumentException
    {
        mImageHeight = chkDimensionalSize( "Height", pHeight );
    }

    public String getUniquingPortion()
    {
        return mUniquingPortion;
    }

    public String getImageEncoding()
    {
        return mImageEncoding;
    }

    /**
     * @param pImageEncoding All Alphas
     *
     * @throws IllegalArgumentException if not null and not all Alphas or not updateable
     */
    private void setImageEncoding( String pImageEncoding )
            throws IllegalArgumentException
    {
        String str = Strings.noEmpty( pImageEncoding );
        if ( str != null )
        {
            Strings.assertAll7BitAsciiAlpha( "ImageEncoding", str = str.toUpperCase() );
        }
        mImageEncoding = str;
    }

    public File createFileAt( File pDirectory )
            throws IllegalStateException, IOException
    {
        required( "Prefix", getPrefix() );
        required( "ImageWidth", getImageWidth() );
        required( "ImageHeight", getImageHeight() );
        required( "ImageEncoding", getImageEncoding() );

        String zFileNamePrefix = createFileNamePrefix();
        String zFileNameExt = createFileNameExt();

        if ( (zFileNamePrefix.length() + zFileNameExt.length()) > 200 )
        {
            throw new IOException( "Prefix & ExtraInfo too long" );
        }

        File zFile = File.createTempFile( zFileNamePrefix, zFileNameExt, pDirectory );

        String zRealFileName = zFile.getName();
        if ( !zRealFileName.startsWith( zFileNamePrefix ) || !zRealFileName.endsWith( zFileNameExt ) )
        {
            zFile.delete();
            throw new IOException( "Temp File Name unacceptable: " + zRealFileName );
        }

        mUniquingPortion = zRealFileName.substring( zFileNamePrefix.length(),
                                                    zRealFileName.length() - zFileNameExt.length() );
        return zFile;
    }

    private static void required( String pWhat, Object pValue )
    {
        if ( pValue == null )
        {
            throw new IllegalStateException( pWhat + " is required" );
        }
    }

    // Kinda (drop leading '0' from UTF-16 characters) Hex encode the passed string
    private static String encodeExtraInfo( String pExtraInfo )
    {
        if ( null == (pExtraInfo = Strings.noEmpty( pExtraInfo )) )
        {
            return "";
        }
        StringBuilder sb = new StringBuilder( pExtraInfo.length() * 2 );
        for ( int i = 0; i < pExtraInfo.length(); i++ )
        {
            char[] zChars = Hex.to4Chars( pExtraInfo.charAt( i ) );
            int si = 0;
            while ( (si < 3) && (zChars[si] == '0') )
            {
                si++;
            }
            while ( si <= 3 )
            {
                sb.append( zChars[si++] );
            }
        }
        return sb.toString();
    }

    private static Integer chkDimensionalSize( String pWhat, Integer pValue )
    {
        if ( (pValue != null) && (pValue < 0) )
        {
            throw new IllegalArgumentException( pWhat + " can NOT be negative" );
        }
        return pValue;
    }
}