package org.litesoft.util;

import java.io.*;

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

import java.util.*;
import java.util.regex.*;

import org.litesoft.logger.*;

public class ShellUtils
{
    public static final Logger LOGGER = LoggerFactory.getLogger( ShellUtils.class );

    /**
     * Splits the specified command at spaces that are not surrounded by quotes and passes the result to {@link #shell(String...)}.
     */
    static public void shell( String command )
    {
        List<String> matchList = new ArrayList<String>();
        Pattern regex = Pattern.compile( "[^\\s\"']+|\"([^\"]*)\"|'([^']*)'" );
        Matcher regexMatcher = regex.matcher( command );
        while ( regexMatcher.find() )
        {
            if ( regexMatcher.group( 1 ) != null )
            {
                matchList.add( regexMatcher.group( 1 ) );
            }
            else if ( regexMatcher.group( 2 ) != null )
            {
                matchList.add( regexMatcher.group( 2 ) );
            }
            else
            {
                matchList.add( regexMatcher.group() );
            }
        }
        shell( matchList.toArray( new String[matchList.size()] ) );
    }

    /**
     * Executes the specified shell command. {@link #resolvePath(String)} is used to locate the file to execute. If not found, on
     * Windows the same filename with an "exe" extension is also tried.
     */
    static public void shell( String... command )
    {
        Strings.assertNotNullNotEmpty( "command", command );

        String originalCommand = (command[0] = Strings.assertNotNullNotEmpty( "shell Command", command[0] ));
        command[0] = resolvePath( command[0] );
        if ( !fileExists( command[0] ) && Utils.isWindows )
        {
            command[0] = resolvePath( command[0] + ".exe" );
            if ( !fileExists( command[0] ) )
            {
                command[0] = originalCommand;
            }
        }

        if ( LOGGER.trace.isEnabled() )
        {
            StringBuilder buffer = new StringBuilder( 256 );
            for ( String text : command )
            {
                if ( text.contains( " " ) )
                {
                    buffer.append( '"' );
                    buffer.append( text );
                    buffer.append( '"' );
                }
                else
                {
                    buffer.append( text );
                }
                buffer.append( ' ' );
            }
            LOGGER.trace.log( "Executing command: ", buffer );
        }

        try
        {
            Process process = new ProcessBuilder( command ).start();
            Thread zOut = new CopyOutputThread( process.getInputStream(), System.out );
            Thread zErr = new CopyOutputThread( process.getErrorStream(), System.err );

            zOut.join();
            zErr.join();
            // try {
            // process.waitFor();
            // } catch (InterruptedException ignored) {
            // }
            if ( process.exitValue() != 0 )
            {
                StringBuilder buffer = new StringBuilder( 256 );
                for ( String text : command )
                {
                    buffer.append( text );
                    buffer.append( ' ' );
                }
                throw new RuntimeException( "Error (" + process.exitValue() + ") executing command: " + buffer );
            }
        }
        catch ( IOException e )
        {
            throw new WrappedIOException( e );
        }
        catch ( InterruptedException e )
        {
            throw new RuntimeException( e );
        }
    }

    /**
     * Returns true if the file exists.
     */
    private static boolean fileExists( String pPath )
    {
        return new File( pPath ).isFile();
    }

    public static String resolvePath( String pPath )
    {
        String zPath = lowLevelResolve( pPath );
        LOGGER.trace.log( "Path \"", pPath, "\" resolved to: ", zPath );
        return zPath;
    }

    private static String lowLevelResolve( String fileName )
    {
        String foundFile;
        if ( fileExists( foundFile = canonical( fileName ) ) )
        {
            return foundFile;
        }
        return fileName;
    }

    /**
     * Returns the canonical path for the specified path. Eg, if "." is passed, this will resolve the actual path and return it.
     */
    private static String canonical( String path )
    {
        path = Strings.assertNotNullNotEmpty( "path", path );

        File file = new File( path );
        try
        {
            return file.getCanonicalPath();
        }
        catch ( IOException ex )
        {
            file = file.getAbsoluteFile();
            if ( file.getName().equals( "." ) )
            {
                file = file.getParentFile();
            }
            return file.getPath();
        }
    }

    public static void main( String[] args )
            throws Exception
    {
        String zEditor = System.getenv( "Editor" );
        if ( zEditor == null )
        {
            throw new IllegalStateException( "No 'Editor' environment variable" );
        }
        shell( zEditor, "src\\org\\litesoft\\util\\FileUtil.java", "src\\org\\litesoft\\util\\FileUtils.java" );
        System.out.println( "ShellUtils.main exiting..." );
    }
}