package org.apidesign.infra.ant;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.FileReader;

 import java.io.IOException;

 import java.net.MalformedURLException;

 import java.net.URL;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.Stack;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import org.apache.tools.ant.BuildException;

 import org.apache.tools.ant.DirectoryScanner;

 import org.apache.tools.ant.Task;

 import org.apache.tools.ant.types.FileSet;

 import org.apache.tools.ant.types.FilterSet;

 /**

  *

  * @author Jaroslav Tulach

  */

 public final class GrepFilter extends Task {

     private int len = 80;

     private String id;

     private FileSet fs;

     private Pattern begin = Pattern.compile(".* BEGIN: *(\\p{Graph}+)[-\\> ]*");

     private Pattern end = Pattern.compile(".* (END|FINISH): *(\\p{Graph}+)[-\\> ]*");

     private boolean openoffice;

     private Map<String,String> paths = new HashMap<String, String>();

     public FileSet createFileSet() {

         if (fs != null) {

             throw new BuildException();

         }

         this.fs = new FileSet();

         return fs;

     }

     public void setId(String id) {

         this.id = id;

     }

     public void setMaxLineLength(int len) {

         this.len = len;

     }

     public void setOutputFormat(String f) {

         if (f.equals("opendocument")) {

             openoffice = true;

             return;

         }

         throw new BuildException("Wrong format: " + f);

     }

     final FilterSet createFilterSet() {

         if (fs == null) {

             throw new BuildException();

         }

         FilterSet filter = new FilterSet();

         try {

             DirectoryScanner ds = fs.getDirectoryScanner(getProject());

             Map<String,CharSequence> texts = new HashMap<String, CharSequence>();

             for (String path : ds.getIncludedFiles()) {

                 File file = new File(ds.getBasedir(), path);

                 BufferedReader r = new BufferedReader(new FileReader(file));

                 for (;;) {

                     String line = r.readLine();

                     if (line == null) {

                         break;

                     }

                     {

                         Matcher m = begin.matcher(line);

                         if (m.matches()) {

                             Item sb = new Item(file);

                             CharSequence prev = texts.put(m.group(1), sb);

                             if (prev != null) {

                                 throw new BuildException("Same pattern is there twice: " + m.group(1) + " in " + file);

                             }

                             continue;

                         }

                     }

                     {

                         Matcher m = end.matcher(line);

                         if (m.matches()) {

                             CharSequence s = texts.get(m.group(2));

                             if (s instanceof Item) {

                                 texts.put(m.group(2), ((Item)s).toString(m.group(1).equals("FINISH")));

                                 continue;

                             }

                             if (s == null) {

                                 throw new BuildException("Closing unknown section: " + m.group(2) + " in " + file);

                             }

                             throw new BuildException("Closing not opened section: " + m.group(2) + " in " + file);

                         }

                     }

                     for (CharSequence charSequence : texts.values()) {

                         if (charSequence instanceof Item) {

                             Item sb = (Item)charSequence;

                             sb.append(line);

                         }

                     }

                 }

                 for (Map.Entry<String, CharSequence> entry : texts.entrySet()) {

                     CharSequence v = entry.getValue();

                     if (v instanceof Item) {

                         throw new BuildException("Not closed section " + entry.getKey() + " in " + file);

                     }

                     entry.setValue(v.toString());

                     if (!paths.containsKey(entry.getKey())) {

                         paths.put(entry.getKey(), path);

                     }

                 }

             }

             for (Map.Entry<String, CharSequence> entry : texts.entrySet()) {

                 String text = entry.getValue().toString();

                 String out = linize(text);

                 filter.addFilter(entry.getKey(), out); // NOI18N

             }

         } catch (IOException ex) {

             throw new BuildException(ex);

         }

         if (!filter.hasFilters()) {

             throw new BuildException("No filter found!");

         }

         return filter;

     }

     @Override

     public void execute() throws BuildException {

         if (id == null) {

             throw new BuildException();

         }

         FilterSet filter = createFilterSet();

         getProject().addReference(id, filter);

     }

     final URL getPath(URL root, String key) throws MalformedURLException {

         return new URL(root, paths.get(key));

     }

     private String linize(String input) {

         if (!openoffice) {

             return input;

         }

         StringBuilder copy = new StringBuilder();

         for (String l : input.split("\n")) {

             int spaces = 0;

             while (spaces < l.length() && l.charAt(spaces) == ' ') {

                 spaces++;

             }

             copy.append("<text:p text:style-name='Code'><text:s text:c='" + spaces + "'/>" + l.substring(spaces) + "</text:p>\n");

         }

         return copy.toString();

     }

     static final int countChar(CharSequence seq, char ch) {

         int cnt = 0;

         for (int i = 0; i < seq.length(); i++) {

             if (ch == seq.charAt(i)) {

                 cnt++;

             }

         }

         return cnt;

     }

     private final class Item implements CharSequence {

         private StringBuilder sb = new StringBuilder();

         private int spaces = Integer.MAX_VALUE;

         private Stack<Integer> remove = new Stack<Integer>();

         private final File file;

         public Item(File file) {

             this.file = file;

         }

         public int length() {

             return sb.length();

         }

         public char charAt(int index) {

             return sb.charAt(index);

         }

         public CharSequence subSequence(int start, int end) {

             return sb.subSequence(start, end);

         }

         private void append(String line) {

             for (int sp = 0; sp < line.length(); sp++) {

                 if (line.charAt(sp) != ' ') {

                     if (sp < spaces) {

                         spaces = sp;

                         break;

                     }

                 }

             }

             remove.push(sb.length());

             sb.append(line);

             sb.append('\n');

         }

         @Override

         public String toString() {

             return toString(false);

         }

         public String toString(boolean finish) {

             if (remove != null) {

                 while (!remove.isEmpty()) {

                    Integer pos = remove.pop();

                    for (int i = 0; i < spaces; i++) {

                        if (sb.charAt(pos) == '\n') {

                            break;

                        }

                        sb.deleteCharAt(pos);

                    }

                 }

                 remove = null;

                 int line = 0;

                 for (int i = 0; i < sb.length(); i++) {

                     if (sb.charAt(i) == '\n') {

                         line = 0;

                         continue;

                     }

                     if (++line > len) {

                         throw new BuildException("Line is too long in: " + file + "\n" + sb);

                     }

                 }

                 int open = countChar(sb, '{');

                 int end = countChar(sb, '}');

                 if (finish) {

                     for (int i = 0; i < open - end; i++) {

                         sb.append("}\n");

                     }

                 }

                 if (countChar(sb, '{') != countChar(sb, '}')) {

                     throw new BuildException("not paired amount of braces in " + file + "\n" + sb);

                 }

             }

             return sb.toString();

         }

     } // end of Item

 }