/**
 * From Apache Uima migration utils file at
 * http://svn.apache.org/repos/asf/incubator/uima/uimaj/trunk/uimaj-tools/src/main/java/org/apache/uima
 * /tools/migration/IbmUimaToApacheUima.java
 */
package org.andromda.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.lang.StringUtils;

/**
 * Iterate down through a directory hierarchy, replace @andromda.whatever.whatever with the Java compliant andromda_whatever_whatever tagged
 * value (attribute) format. Open .zip files if necessary.
 * 
 * @author RJF3
 */
public class GlobalPatternFileReplace
{
    private static List<Replacement> replacements = new ArrayList<Replacement>();
    private static int MAX_FILE_SIZE = 10000000; // don't update files bigger than 10 MB
    private static Set<String> extensions = new HashSet<String>();
    private static int filesScanned = 0;
    private static int filesModified = 0;
    private static int fileReplacements = 0;

    /**
     * 
     */
    public GlobalPatternFileReplace()
    {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException
    {
        File file = new File("C:/workspaces/A34/andromda341/cartridges/andromda-spring/pom.xml");
        // parse command line
        String dir = null;
        for (int i = 0; i < args.length; i++)
        {
            if (args[i].startsWith("-"))
            {
                if (args[i].equals("-ext"))
                {
                    if (i + 1 >= args.length)
                    {
                        printUsageAndExit();
                    }
                    parseCommaSeparatedList(args[++i], extensions);
                }
                else
                {
                    System.err.println("Unknown switch " + args[i]);
                    printUsageAndExit();
                }
            }
            else
            {
                if (dir != null)
                {
                    printUsageAndExit();
                }
                else
                {
                    dir = args[i];
                    file = new File(dir);
                }
            }
        }
        /*if (dir == null)
        {
            //file = new File(".");
            //System.out.println("Using default current directory: " + file.getCanonicalPath());
            file = new File("C:/workspaces/A34/andromda341/cartridges/andromda-spring");
            //printUsageAndExit();
        }
        if (file == null)
        {
            printUsageAndExit();
            return;
        }*/
        if (extensions.isEmpty())
        {
            parseCommaSeparatedList("xml,java,xml.zip,vsl,vm", extensions);
        }

        try
        {
            /*
            replaceInFile(file); //read resource files //map from IBM UIMA package names to Apache UIMA package names
            */
            readMapping("packageMapping.txt", replacements, true);
            //other string replacements readMapping("stringReplacements.txt", replacements, false);

            // from system property, get list of file extensions to exclude
            // do the replacements
            System.out.println("Migrating your files in " + file.getCanonicalPath());
            replaceInAllFiles(file);
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("Migration complete.");
        System.out.println("Scanned " + filesScanned + " files.  " + filesModified + " files modified.");
    }

    /**
     * 
     */
    private static void printUsageAndExit()
    {
        System.err.println("Usage: java " + GlobalPatternFileReplace.class.getName() + " <directory> [-ext <fileExtensions>]");
        System.err.println("<fileExtensions> is a comma separated list of file extensions to process, e.g.: java,xml,properties");
        System.err.println("\tUse a trailing comma to include files with no extension (meaning their name contains no dot)");
        System.exit(1);
    }

    /**
     * Applies the necessary replacements to all files in the given directory. Subdirectories are processed recursively.
     * Filters out SVN files and target directory by default.
     * 
     * @param dir directory containing files to replace
     * @throws IOException if an I/O error occurs
     */
    private static void replaceInAllFiles(File dir) throws IOException
    {
        if (dir.isDirectory())
        {
            IOFileFilter fileFilter = FileFilterUtils.trueFileFilter();
            IOFileFilter notTargetFileFilter = FileFilterUtils.notFileFilter(FileFilterUtils.nameFileFilter("target"));
            IOFileFilter dirFilter = FileFilterUtils.and(FileFilterUtils.makeSVNAware(null), notTargetFileFilter);
            Collection<File> files = FileUtils.listFiles(dir, fileFilter, dirFilter);
            for (File file : files)
            {
                if (file.isFile())
                {
                    boolean process = false;
                    // Check files against extensions filter
                    for (String ext : extensions)
                    {
                        if (file.getName().endsWith("." + ext))
                        {
                            process = true;
                            break;
                        }
                    }
                    if (process)
                    {
                        // do the replacements
                        // for .zip files, unzip, replace, and put back in archive
                        if (file.getName().endsWith(".zip"))
                        {
                            replaceInArchive(file);
                        }
                        else
                        {
                            replaceInFile(file);
                        }
                    }
                }
    
                // recursively call on subdirectories
                else if (file.isDirectory())
                {
                    replaceInAllFiles(file);
                }
            }
        }
        if (dir.isFile())
        {
            if (dir.getName().endsWith(".zip"))
            {
                replaceInArchive(dir);
            }
            else
            {
                replaceInFile(dir);
            }
        }
    }

    /**
     * Checks if file exists and is not excluded by extension and is writable.
     * 
     * @param file the file to process
     */
    private static boolean checkAttributes(File file) throws IOException
    {
        // skip files with extensions specified in the excludes list
        if (!extensions.isEmpty())
        {
            String filename = file.getName();
            String ext = "";
            int lastDot = filename.lastIndexOf('.');
            if (lastDot > -1)
            {
                ext = filename.substring(lastDot + 1);
            }
            if (!extensions.contains(ext.toLowerCase()))
            {
                return false;
            }
        }

        // make writable files that are readonly
        if (!file.canRead())
        {
            //new FilePermission(file.getCanonicalPath(), "read,write,execute,delete");
            //file.setReadable(true, false);
            System.err.println("Can't read file: " + file.getCanonicalPath());
            //continue;
        }
        /*if (!file.canWrite())
        {
            System.err.println("Skipping unwritable file: " + file.getCanonicalPath());
            return false;
        }*/
        // skip files that are too big
        if (file.length() > MAX_FILE_SIZE)
        {
            System.out.println("Skipping file " + file.getCanonicalPath() + " with size: " + file.length() + " bytes");
            return false;
        }

        return true;
    }

    /**
     * Applies replacements to a single file.
     * 
     * @param file the file to process
     */
    private static int replaceInArchive(File file) throws IOException
    {
        // do the replacements in each file in the archive
        
        int replacements = 0;
        // for .zip files, unzip, replace, and put back in archive
        if (file.isFile() && file.getName().endsWith(".zip"))
        {
            File location = unpack(file);
            IOFileFilter fileFilter = FileFilterUtils.suffixFileFilter("xml");
            IOFileFilter dirFilter = FileFilterUtils.makeCVSAware(null);
            Collection<File> archiveFiles = FileUtils.listFiles(location, fileFilter, dirFilter);
            for (File archiveFile : archiveFiles)
            {
                // Only update zip archive contents if they have changed
                int replacement = replaceInFile(archiveFile);
                if (replacement > 0)
                {
                    pack(file, archiveFile.getAbsolutePath());
                    replacements += replacement;
                }
                archiveFile.delete();
            }
            location.delete();
        }
        return replacements;
    }

    /**
     * Applies replacements to a single file.
     * 
     * @param file the file to process
     */
    private static int replaceInFile(File file) throws IOException
    {
        // do the replacements
        fileReplacements = 0;
        if (!checkAttributes(file))
        {
            return fileReplacements;
        }
        String original;
        try
        {
            original = FileUtils.readFileToString(file);
        }
        catch (IOException e)
        {
            System.err.println("Error reading " + file.getCanonicalPath());
            System.err.println(e.getMessage());
            return fileReplacements;
        }
        String contents = original;
        contents = replaceInPattern(contents);

        // write file if it changed
        if (!contents.equals(original))
        {
            if (!file.canWrite())
            {
                // JDK 1.6 only. How do we make file writable in JDK 1.5?
                file.setReadable(true, false);
                System.out.println("Making file writable: " + file.getCanonicalPath());
                //new FilePermission(file.getCanonicalPath(), "read,write,execute,delete");               
            }
            if (!file.canWrite())
            {
                System.err.println("Could not make file writable: " + file.getCanonicalPath());
            }
            else
            {
                FileUtils.writeStringToFile(file, contents);
                filesModified++;
            }
            System.out.println(file.getAbsolutePath() + " " + fileReplacements + " replacements");
        }
        filesScanned++;

        // check for situations that may need manual attention,
        // updates filesNeedingManualAttention field
        // checkForManualAttentionNeeded(file, original);
        return fileReplacements;
    }

    /**
     * Unpacks the archive file.
     *
     * @param file File to be unpacked.
     * @return File directory where contents were unpacked
     * @throws IOException 
     */
    protected static File unpack(
        final File file)
        throws IOException
    {
        return unpack(file, null);
    }

    /**
     * Unpacks the archive file.
     *
     * @param file File to be unpacked.
     * @param location Location where to put the unpacked files.
     * @return File directory where contents were unpacked
     * @throws IOException 
     */
    protected static File unpack(
        final File file,
        File location)
        throws IOException
    {
        final int ext = file.getAbsolutePath().lastIndexOf('.');
        if (ext<1)
        {
            throw new IOException("File has no extension: " + file.getAbsolutePath());
        }
            
        if (location==null || !location.exists())
        {
            location = new File(file.getParent() + "/" + StringUtils.remove(file.getName(), '.') + "/");
        }
        if (!location.getAbsolutePath().endsWith("/") && !location.getAbsolutePath().endsWith("\\"))
        {
            location = new File(location.getAbsolutePath() + "/");
        }
        if (!location.exists())
        {
            // Create the directory
            FileUtils.forceMkdir(location);
        }
        //final String archiveExt = file.getAbsolutePath().substring(ext+1);
        //final String archiveExt = FileUtils.getExtension(file.getAbsolutePath()).toLowerCase();
        try
        {
            /*ZipFile zipFile = new ZipFile(file);
            for (File fileEntry : zipFile.entries())
            final UnArchiver unArchiver = GlobalPatternFileReplace.archiverManager.getUnArchiver(archiveExt);
            unArchiver.setSourceFile(file);
            unArchiver.setDestDirectory(location);
            unArchiver.extract();
            }
        catch (Throwable throwable)
        {
            if (throwable instanceof IOException || throwable instanceof ArchiverException)
            {
                throw new IOException("Error unpacking file: " + file + "to: " + location, throwable);
            //}
        }*/
            byte[] buf = new byte[1024];
            ZipInputStream zipinputstream = null;
            ZipEntry zipentry;
            zipinputstream = new ZipInputStream(new FileInputStream(file));
    
            zipentry = zipinputstream.getNextEntry();
            while (zipentry != null) 
            { 
                //for each entry to be extracted
                String entryName = zipentry.getName();
                //System.out.println("entryname "+entryName);
                FileOutputStream fileoutputstream;
                File newFile = new File(entryName);
                String directory = newFile.getParent();
                
                if(directory == null)
                {
                    if(newFile.isDirectory())
                        break;
                }
                
                File output = new File(location.getAbsolutePath(), entryName);
                fileoutputstream = new FileOutputStream(output);             
    
                int n;
                while ((n = zipinputstream.read(buf, 0, 1024)) > -1)
                    fileoutputstream.write(buf, 0, n);
    
                fileoutputstream.close(); 
                zipinputstream.closeEntry();
                zipentry = zipinputstream.getNextEntry();
    
            }//while
    
            zipinputstream.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return location;
    }

    /**
     * Writes the given archive file and includes
     * the file given by the <code>path</code>
     *
     * @param zipArchive the zip archive.
     * @param path the path of the file to write to the zip archive.
     * @throws IOException
     */
    private static void pack(
        final File zipArchive,
        final String path)
        throws IOException
    {
        // - retrieve the name of the file given by the path.
        /*final String name = path.replaceAll(
                PATH_REMOVE_PATTERN,
                "");*/
        //final String name = zipArchive.getName();
        final ZipOutputStream zipOutputStream = new ZipOutputStream(new FileOutputStream(zipArchive));
        File pathFile = new File(path);
        final ZipEntry zipEntry = new ZipEntry(pathFile.getName());
        zipEntry.setMethod(ZipEntry.DEFLATED);
        zipOutputStream.putNextEntry(zipEntry);
        final FileInputStream inputStream = new FileInputStream(path);
        final byte[] buffer = new byte[1024];
        int n = 0;
        while ((n =
                inputStream.read(
                    buffer,
                    0,
                    buffer.length)) > 0)
        {
            zipOutputStream.write(
                buffer,
                0,
                n);
        }
        inputStream.close();
        zipOutputStream.closeEntry();
        zipOutputStream.close();
    }

    /**
     * Replaces values within a regex match for each replacement in replacements list
     * 
     * @param contents File contents string
     * @param replacement The pattern, replace, replaceWith, and deleteStr values
     */
    private static String replaceInPattern(String contents)
    {
        // apply replacements
        for (Replacement replacement : replacements)
        {
            // contents = contents.replaceAll(replacement.regex, replacement.replacementStr);
            contents = replaceInPattern(contents, replacement);
        }
        return contents;
    }

    /**
     * Replaces values within a regex match
     * 
     * @param contents File contents string
     * @param replacement The pattern, replace, replaceWith, and deleteStr values
     */
    private static String replaceInPattern(String contents, Replacement replacement)
    {
        // StringBuffer contentBuffer = new StringBuffer(contents);
        Matcher matcher = replacement.pattern.matcher(contents);
        StringBuffer sb = new StringBuffer();
        while (matcher.find())
        {
            boolean ignoreString = false;
            String toReplace = contents.substring(matcher.start(), matcher.end());
            for (String ignorePattern : replacement.ignorePatterns)
            {
                if (toReplace.indexOf(ignorePattern) > -1)
                {
                    ignoreString = true;
                    break;
                }
            }
            if (!ignoreString)
            {
                toReplace = toReplace.replace(replacement.replaceStr, replacement.replaceWithStr);
                toReplace = StringUtils.remove(toReplace, replacement.deleteStr);
                matcher.appendReplacement(sb, toReplace);
                fileReplacements++;
            }
        }
        sb = matcher.appendTail(sb);
        return sb.toString();
    }

    /**
     * Parses a comma separated list, entering each value into the results Collection. Trailing empty strings are included in the results
     * Collection.
     * 
     * @param string string to parse
     * @param results Collection to which each value will be added
     */
    private static Set<String> parseCommaSeparatedList(String string, Set<String> results)
    {
        String[] components = string.split(",", -1);
        if (results==null)
        {
            results = new HashSet<String>();
        }
        for (int i = 0; i < components.length; i++)
        {
            results.add(components[i]);
        }
        return results;
    }

    /**
     * Reads a mapping from a resource file, and populates a List of Replacement objects. We don't use a Map because the order in which the
     * replacements are applied can be important.
     * 
     * @param fileName
     *            name of file to read from (looked up looking using Class.getResource())
     * @param mappings
     *            List to which Replacement objects will be added. Each object contains the regex to search for and the replacement string.
     * @param treatAsPackageNames
     *            if true, the keys in the resource file will be considered package names, and this routine will produce regexes that
     *            replace any fully-qualified class name belonging to that package. Also in this case updates the static ibmPackageNames
     *            HashSet.
     */
    private static void readMapping(String fileName, List mappings, boolean treatAsPackageNames) throws IOException
    {
        // Placeholder until txt file is built/read
        //List<String> ignorePatterns = new ArrayList<String>();
        //ignorePatterns.add(".cvs.");
        // Find pattern @andromda. followed by lowercase letters followed by period (repeating groups) followed by lowercase letter
        Replacement replacement = new Replacement("@andromda.([a-z]+[\\\\.])+[a-z]", ".", "_", "@", parseCommaSeparatedList(".cvs.", null));
        GlobalPatternFileReplace.replacements.add(replacement);

        /*URL pkgListFile = AtAndromdaCleanup.class.getResource(fileName);
        InputStream inStream = pkgListFile.openStream();
        BufferedReader reader = new BufferedReader(new InputStreamReader(inStream));
        String line = reader.readLine();
        while (line != null)
        {
            String[] mapping = line.split(" ");
            String regex, replaceStr;
            if (treatAsPackageNames)
            {
                // we do special processing for package names to try to handle the case where
                // user code exists in a package prefixed by com.ibm.uima.
                // We only replace the package name when it appears as part of a fully-qualified
                // class name in that package, not as a prefix of another package.

                // turn package name into a regex (have to escape the . and,
                // technically, should allow whitepsace around dots)
                String pkgRegex = mapping[0].replaceAll("\\.", "\\\\s*\\\\.\\\\s*");
                // form regex that will find any fully-qualified class name in this package
                regex = pkgRegex + "(\\.(\\*|[A-Z]\\w*))";
                replaceStr = mapping[1] + "$1";
                // ibmPackageNames.add(mapping[0]);
            }
            else
            {
                // form regex from src, by escaping dots and allowing whitespace
                regex = mapping[0].replaceAll("\\.", "\\\\s*\\\\.\\\\s*");
                replaceStr = mapping[1];
            }

            // Regex for @andromda.([a-z]+[\.])+ matches @andromda. plus repeating sequence of lowercase letters followed by period
            // replace . with _ in all occurrences within the matched pattern result String, remove @
            List<String> ignorePatterns = new ArrayList<String>();
            ignorePatterns.add(".cvs.");
            Replacement replacement = new Replacement("@andromda.([a-z]+[\\\\.])+", ".", "_", "@", ignorePatterns);
            // Replacement replacement = new Replacement(regex, replaceStr);
            mappings.add(replacement);
            line = reader.readLine();
        }
        inStream.close();*/
    }

    /**
     * Replace all occurrences of replacement String with replaceWithString inside regex result Delete all occurrences of deleteStr inside
     * regex result
     * 
     * @author RJF3
     */
    private static class Replacement
    {
        String regex;
        String deleteStr;
        String replaceStr;
        String replaceWithStr;
        Set<String> ignorePatterns;
        Pattern pattern;

        /**
         * @param regexIn Input regular expression
         * @param replacement String to replace text within the existing string
         * @param replaceWithIn String to replace with
         * @param deleteStrIn String to delete within the existing String
         * @param ignorePatternsIn If one of the patterns exists in the existing String, skip replacements
         */
        Replacement(String regexIn, String replacement, String replaceWithIn, String deleteStrIn, Set<String> ignorePatternsIn)
        {
            this.regex = regexIn;
            this.replaceStr = replacement;
            this.deleteStr = deleteStrIn;
            this.replaceWithStr = replaceWithIn;
            this.ignorePatterns = ignorePatternsIn;
            this.pattern = Pattern.compile(regex);
        }
    }
}