package org.kuali.student.core.dictionary.service.impl;

 import java.io.File;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.OutputStream;

 import java.io.PrintStream;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.LinkedHashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.kuali.student.core.dictionary.dto.ObjectStructureDefinition;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class DictionaryTesterHelper

 {

  private String outputFileName;

  private File file;

  private OutputStream outputStream;

  private PrintStream out;

  private Set<String> startingClasses;

  private String dictFileName;

  private boolean processSubstructures = false;

  public DictionaryTesterHelper (String outputFileName,

                                 Set<String> startingClasses,

                                 String dictFileName,

                                 boolean processSubstructures)

  {

   this.outputFileName = outputFileName;

   this.startingClasses = startingClasses;

   this.dictFileName = dictFileName;

   this.processSubstructures = processSubstructures;

   // get printstream from file

   this.file = new File (this.outputFileName);

   try

   {

    outputStream = new FileOutputStream (file, false);

   }

   catch (FileNotFoundException ex)

   {

    throw new IllegalArgumentException (ex);

   }

   this.out = new PrintStream (outputStream);

  }

  private transient Map<String, ObjectStructureDefinition> objectStructures;

  public List<String> doTest ()

  {

   ApplicationContext ac = new ClassPathXmlApplicationContext (

       "classpath:" + dictFileName);

   objectStructures = new HashMap ();

   Map<String, ObjectStructureDefinition> beansOfType =

                                          (Map<String, ObjectStructureDefinition>) ac.

       getBeansOfType (ObjectStructureDefinition.class);

   for (ObjectStructureDefinition objStr: beansOfType.values ())

   {

    objectStructures.put (objStr.getName (), objStr);

    System.out.println ("Loading object structure: " + objStr.getName ());

   }

   // First validate all the starting classes

   for (String className: startingClasses)

   {

    ObjectStructureDefinition os = null;

    os = objectStructures.get (className);

    if (os == null)

    {

     throw new RuntimeException ("className is not defined in dictionary: " + className);

    }

    DictionaryValidator validator = new DictionaryValidator (os,

                                                             new HashSet (),

                                                             false);

    List<String> errors = validator.validate ();

    if (errors.size () > 0)

    {

     return errors;

    }

   }

   Set<String> allStructures = new LinkedHashSet ();

   for (String className: startingClasses)

   {

    allStructures.addAll (getComplexSubStructures (className));

   }

   Set<String> classesToProcess = null;

   if (this.processSubstructures)

   {

    classesToProcess = startingClasses;

 //   System.out.println ("Processing just the starting classes but then processing their substructures in-line");

   }

   else

   {

    classesToProcess = allStructures;

 //   System.out.println ("Processing all substructures as separate entitiies");

   }

   out.println ("(!) This page was automatically generated on " + new Date ());

   out.println ("DO NOT UPDATE MANUALLY!");

   out.println ("");

   out.print ("This page represents a formatted view of [" + dictFileName

              + "|https://test.kuali.org/svn/student/trunk/ks-lum/ks-lum-impl/src/main/resources/"

              + dictFileName + "]");

   out.println (

       " and is compared to the following java classes (and their sub-classes) for discrepancies:");

   for (String className: startingClasses)

   {

    out.println ("# " + className);

   }

   out.println ("");

   out.println ("----");

   out.println ("{toc}");

   out.println ("----");

   for (String className: classesToProcess)

   {

 //   System.out.println ("processing class " + clazz.getSimpleName ());

    doTestOnClass (className, ac);

   }

   out.close ();

   return new ArrayList ();

  }

  private Set<String> getComplexSubStructures (String className)

  {

   return new ComplexSubstructuresHelper ().getComplexStructures (className);

  }

  private void doTestOnClass (String className, ApplicationContext ac)

  {

   ObjectStructureDefinition os =   os = objectStructures.get (className);

   String simpleName = calcSimpleName (className);

   if (os == null)

   {

    out.println ("h1. " + simpleName);

    out.println ("{anchor:" + simpleName + "}");

    out.println ("h2. Error could not find a corresponding dictionary definition");

    return;

   }

   DictionaryFormatter formatter =

                       new DictionaryFormatter (className,

                                                className,

                                                os,

                                                new HashSet (),

                                                1, // header level to start at

                                                this.processSubstructures);

   out.println (formatter.formatForWiki ());

  }

  private String calcSimpleName (String name)

  {

   if (name.lastIndexOf (".") != -1)

   {

    name = name.substring (name.lastIndexOf (".") + 1);

   }

   return name;

  }

 }