package org.opends.build.tools;

import com.vladium.emma.*;
import com.vladium.emma.report.*;
import com.vladium.emma.data.*;
import com.vladium.util.IntObjectMap;

import java.io.*;
import java.util.Iterator;
import java.util.ArrayList;

public class CoverageDiff {


  private static boolean verbose = false;

  public static void main(String[] args) {

    if(args.length < 1 || args[0] == null)
    {
      System.out.println("Please specify emma data location");
      return;
    }
    IReportDataView emmaDataView = null;
    try
    {
      emmaDataView = loadEmmaData(new File(args[0].trim()));

    }
    catch(IOException ie)
    {
      System.out.println("An error occured while loading EMMA data: " + ie.toString());
    }

    if(emmaDataView == null)
    {
      System.out.println(System.in);
    }
    else
    {
      try
      {
        processDiffOutput(new BufferedReader(new InputStreamReader(System.in)), emmaDataView);
      }
      catch(IOException ie)
      {
        System.out.println("An error occured while processing diff output: " + ie.toString());
      }
    }
  }


  private static IReportDataView loadEmmaData(File emmaCoverageDataDir) throws IOException {
    File[] emmaCoverageDataFiles = emmaCoverageDataDir.listFiles();
    int emmaCoverageDataFileCount = 0;
    IReportDataView m_view = null;
    IMetaData mdata = null;
    ICoverageData cdata = null;

    if(emmaCoverageDataFiles == null || emmaCoverageDataFiles.length <= 0)
    {
      throw new IOException("No EMMA data files found");
    }

    if (verbose) System.out.println("processing input files ...");

    final long start = verbose ? System.currentTimeMillis() : 0;

    // merge all data files:

    for (int f = 0; f < emmaCoverageDataFiles.length; ++f) {
      final File dataFile = emmaCoverageDataFiles[f];
      if (verbose)
        System.out.println("processing input file [" + dataFile.getAbsolutePath() + "] ...");

      final IMergeable[] fileData = DataFactory.load(dataFile);

      final IMetaData _mdata = (IMetaData) fileData[DataFactory.TYPE_METADATA];
      if (_mdata != null) {
        if (verbose)
          System.out.println("  loaded " + _mdata.size() + " metadata entries");

        if (mdata == null)
          mdata = _mdata;
        else
          mdata = (IMetaData) mdata.merge(_mdata); // note: later datapath entries override earlier ones
      }

      final ICoverageData _cdata = (ICoverageData) fileData[DataFactory.TYPE_COVERAGEDATA];
      if (_cdata != null) {
        if (verbose)
          System.out.println("  loaded " + _cdata.size() + " coverage data entries");

        if (cdata == null)
          cdata = _cdata;
        else
          cdata = (ICoverageData) cdata.merge(_cdata); // note: later datapath entries override earlier ones
      }

      ++emmaCoverageDataFileCount;
    }

    if (verbose) {
      final long end = System.currentTimeMillis();

      System.out.println(emmaCoverageDataFileCount + " file(s) read and merged in " + (end - start) + " ms");
    }

    if ((mdata == null) || mdata.isEmpty()) {
      System.out.println("nothing to do: no metadata found in any of the data files");
      return null;
    }

    if (cdata == null) {
      System.out.println("nothing to do: no runtime coverage data found in any of the data files");
      return null;
    }

    if (cdata.isEmpty()) {
      System.out.println("no collected coverage data found in any of the data files [Diff output will not include coverage data]");
      return null;
    }
    if (!mdata.hasLineNumberData() || !mdata.hasSrcFileData()) {
      System.out.println("no collected line coverage data found in any of the data files [Diff output will not include coverage data]");
      return null;
    }

    final IReportDataModel model = IReportDataModel.Factory.create (mdata, cdata);
    m_view = model.getView (IReportDataView.HIER_SRC_VIEW);

    if (verbose) {
      if (mdata != null) {
        System.out.println("  merged metadata contains " + mdata.size() + " entries");
      }

      if (cdata != null) {
        System.out.println("  merged coverage data contains " + cdata.size() + " entries");
      }
    }

    return m_view;
  }

  private static BufferedReader getDiffOutputReader() throws IOException {

    Process child = Runtime.getRuntime().exec("svn diff");
    InputStream diffOutputStream = child.getInputStream();
    BufferedReader diffOutput = new BufferedReader(
        new InputStreamReader(diffOutputStream));
    return diffOutput;

  }

  private static void processDiffOutput(BufferedReader diffOutput,
                                        IReportDataView emmaDataView)
      throws IOException {

    String line = diffOutput.readLine();
    ArrayList<String> diffOutputFile = new ArrayList<String>();

    while(line != null)
    {
      //Diffed file
      if(line.length() >6 && line.substring(0, 6).equals("Index:"))
      {
        processDiffOutputFile(diffOutputFile, emmaDataView);
        diffOutputFile = new ArrayList<String>();
        diffOutputFile.add(line);
      }
      else
      {
        diffOutputFile.add(line);
      }

      line = diffOutput.readLine();
    }
    processDiffOutputFile(diffOutputFile, emmaDataView);
  }

  private static void processDiffOutputFile(ArrayList<String> diffFile,
                                            IReportDataView emmaDataView)
      throws IOException
  {
    if(diffFile.size() <= 0)
    {
      return;
    }
    
    String fileHeader = diffFile.get(0);

    File srcFilePath = new File(fileHeader.substring(7));
    FileInputStream srcFile = new FileInputStream(srcFilePath);
    String srcFilePackage = parseJavaPackage(srcFile);
    SrcFileItem emmaSourceItem = getEmmaSrcItem(emmaDataView.getRoot(),
                  srcFilePackage, srcFilePath.getName());

    if(emmaSourceItem == null)
    {
      System.out.println(fileHeader);
      System.out.println("Coverage: Not Available");
      for(int i = 1; i < diffFile.size(); i++)
      {
        System.out.println(diffFile.get(i));
      }
    }
    else
    {
      System.out.println(fileHeader);

      System.out.print("Coverage: ");
      String name;
      StringBuffer buf = new StringBuffer();
      for(int i = 1; i <= 4; i++)
      {
        buf.setLength(0);
        emmaSourceItem.getAttribute(i, 0).format(emmaSourceItem, buf);
        name = emmaSourceItem.getAttribute(i, 0).getName();
        System.out.print(name);
        for(int j = 0; j < buf.length() - name.length() + 1; j++)
        {
          System.out.print(" ");
        }
      }
      System.out.print("\n          ");
      for(int i = 1; i <= 4; i++)
      {
        buf.setLength(0);
        emmaSourceItem.getAttribute(i, 0).format(emmaSourceItem, buf);
        System.out.print(buf + " ");
      }
      System.out.println("");

      System.out.println(diffFile.get(1));

      //Figure out the flag for the working copy.
      String workingCopyFlag = null;
      String otherCopyFlag = null;

      String firstFileLine = diffFile.get(2);
      String secondFileLine = diffFile.get(3);
      System.out.println(firstFileLine);
      System.out.println(secondFileLine);

      if(firstFileLine.endsWith("(working copy)"))
      {
        workingCopyFlag = firstFileLine.substring(0, 1);
      }
      else
      {
        otherCopyFlag = firstFileLine.substring(0, 1);
      }

      if(secondFileLine.endsWith("(working copy)"))
      {
        workingCopyFlag = secondFileLine.substring(0, 1);
      }
      else
      {
        otherCopyFlag = secondFileLine.substring(0, 1);
      }

      if(firstFileLine.endsWith("(revision 0)") &&
          secondFileLine.endsWith("(revision 0)"))
      {
        workingCopyFlag = "+";
        otherCopyFlag = "-";
      }

      if(workingCopyFlag == null || otherCopyFlag == null ||
          srcFilePackage == null)
      {
        for(int i = 4; i < diffFile.size(); i++)
        {
          System.out.println(diffFile.get(i));
        }
      }
      else
      {

        ArrayList<String> diffOutputChunk = new ArrayList<String>();

        for(int i = 4; i < diffFile.size(); i++)
        {
          //Found a chunk indicator.
          if(diffFile.get(i).startsWith("@@"))
          {
            processDiffOutputFileChunk(diffOutputChunk, workingCopyFlag,
                otherCopyFlag, emmaSourceItem);
            diffOutputChunk = new ArrayList<String>();
            diffOutputChunk.add(diffFile.get(i));
          }
          //Not any of the above so this line must be diffed text
          else
          {
            diffOutputChunk.add(diffFile.get(i));
          }
        }

        //Finishing process whatever we have queued up
        processDiffOutputFileChunk(diffOutputChunk, workingCopyFlag,
            otherCopyFlag, emmaSourceItem);
      }
    }

  }

  private static void processDiffOutputFileChunk(ArrayList<String> diffChunk,
                                                 String workingCopyFlag,
                                                 String otherCopyFlag,
                                                 SrcFileItem emmaSrcItem)
  {

    if(diffChunk.size() <= 0)
    {
      return;
    }

    int workingCopyBegin;
    int workingCopyRange;
    int otherCopyBegin;
    int otherCopyRange;

    IntObjectMap lineCoverageMap = null;
    if(emmaSrcItem != null)
    {
      lineCoverageMap = emmaSrcItem.getLineCoverage ();
    }

    String chunkHeader = diffChunk.get(0);
    System.out.println(chunkHeader);

    int workingCopyBeginIdx = chunkHeader.indexOf(workingCopyFlag);
    int workingCopyCommaIdx = chunkHeader.indexOf(",", workingCopyBeginIdx);
    int workingCopyEndIdx = chunkHeader.indexOf(" ", workingCopyCommaIdx);
    int otherCopyBeginIdx = chunkHeader.indexOf(otherCopyFlag);
    int otherCopyCommaIdx = chunkHeader.indexOf(",", otherCopyBeginIdx);
    int otherCopyEndIdx = chunkHeader.indexOf(" ", otherCopyCommaIdx);
    workingCopyBegin = Integer.parseInt(
        chunkHeader.substring(workingCopyBeginIdx + 1, workingCopyCommaIdx));
    workingCopyRange = Integer.parseInt(
        chunkHeader.substring(workingCopyCommaIdx + 1, workingCopyEndIdx));
    otherCopyBegin = Integer.parseInt(
        chunkHeader.substring(otherCopyBeginIdx + 1, otherCopyCommaIdx));
    otherCopyRange = Integer.parseInt(
        chunkHeader.substring(otherCopyCommaIdx + 1, otherCopyEndIdx));

    String chunkLine;
    SrcFileItem.LineCoverageData lCoverageData = null;
    int workingCopyLineIncrement = 0;
    int otherCopyLineIncrement = 0;
    for(int i = 1; i < diffChunk.size(); i++)
    {
      chunkLine = diffChunk.get(i);
      //System.out.print(workingCopyBegin + workingCopyLineIncrement + " ");
      if(lineCoverageMap != null)
      {
        lCoverageData = (SrcFileItem.LineCoverageData) lineCoverageMap.get (workingCopyBegin + workingCopyLineIncrement);
      }

      if(!chunkLine.startsWith(otherCopyFlag) && lCoverageData != null)
      {

        switch(lCoverageData.m_coverageStatus)
        {
          case SrcFileItem.LineCoverageData.LINE_COVERAGE_ZERO:
            System.out.println(chunkLine.charAt(0) + "N" + chunkLine.substring(1));
            break;
          case SrcFileItem.LineCoverageData.LINE_COVERAGE_PARTIAL:
            System.out.println(chunkLine.charAt(0) + "P" + chunkLine.substring(1));
            break;
          case SrcFileItem.LineCoverageData.LINE_COVERAGE_COMPLETE:
            System.out.println(chunkLine.charAt(0) + "C" + chunkLine.substring(1));
            break;
          default:
            System.out.println(chunkLine.charAt(0) + "U" + chunkLine.substring(1));
        }
      }
      else
      {
        System.out.println(chunkLine.charAt(0) + " " + chunkLine.substring(1));
      }

      if(!chunkLine.startsWith(otherCopyFlag))
      {
        workingCopyLineIncrement++;
      }
      if(!chunkLine.startsWith(workingCopyFlag))
      {
        otherCopyLineIncrement++;
      }
    }
  }

  private static String parseJavaPackage(FileInputStream srcFile)
      throws IOException {

    BufferedReader srcFileReader = new BufferedReader(
        new InputStreamReader(srcFile));

    String line = srcFileReader.readLine();
    while(line != null)
    {
      int beginIdx = line.indexOf("package");
      if(beginIdx > -1)
      {
        int endIdx = line.indexOf(";", beginIdx);
        if(endIdx > -1)
        {
          return  line.substring(beginIdx + 7, endIdx).trim();
        }
      }
      line = srcFileReader.readLine();
    }

    return null;
  }

  private static SrcFileItem getEmmaSrcItem(IItem rootItem,
                                      String srcPackageName,
                                      String srcFileName)
  {
    for(Iterator packages = rootItem.getChildren(); packages.hasNext();)
    {
      IItem packageItem = (IItem)packages.next();
      if(packageItem.getName().equals(srcPackageName))
      {
        for(Iterator sources = packageItem.getChildren(); sources.hasNext();)
        {
          SrcFileItem sourceItem = (SrcFileItem)sources.next();
          if(sourceItem.getName().equals(srcFileName))
          {
            return sourceItem;
          }
        }
      }
    }
    return null;
  }
}