package xalanjdoc;

import com.sun.javadoc.ClassDoc;
import com.sun.javadoc.DocErrorReporter;
import com.sun.javadoc.PackageDoc;
import com.sun.javadoc.RootDoc;
import com.sun.tools.doclets.ClassTree;
import com.sun.tools.doclets.DocletAbortException;
import com.sun.tools.doclets.HtmlDocWriter;
import com.sun.tools.doclets.IndexBuilder;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Standard {
   protected String classFileName(ClassDoc cd) {
      return cd.qualifiedName() + ".html";
   }

   public static ConfigurationStandard configuration() {
      if (HtmlDocWriter.configuration == null) {
         HtmlDocWriter.configuration = new ConfigurationStandard();
      }

      return (ConfigurationStandard)HtmlDocWriter.configuration;
   }

   public static void copyFile(File destfile, File srcfile) throws DocletAbortException, IOException {
      byte[] bytearr = new byte[512];
      int len = 0;
      FileInputStream input = new FileInputStream(srcfile);
      FileOutputStream output = new FileOutputStream(destfile);

      try {
         while((len = input.read(bytearr)) != -1) {
            output.write(bytearr, 0, len);
         }
      } catch (FileNotFoundException var11) {
         throw new DocletAbortException();
      } catch (SecurityException var12) {
         throw new DocletAbortException();
      } finally {
         input.close();
         output.close();
      }
   }

   protected void generateClassCycle(ClassDoc[] arr, ClassTree classtree, boolean nopackage) throws DocletAbortException {
      Arrays.sort((Object[])arr);

      for(int i = 0; i < arr.length; ++i) {
         if (!configuration().nodeprecated || arr[i].tags("deprecated").length <= 0) {
            ClassDoc prev = i == 0 ? null : arr[i - 1];
            ClassDoc curr = arr[i];
            ClassDoc next = i + 1 == arr.length ? null : arr[i + 1];
            ClassWriter.generate(curr, prev, next, classtree, nopackage);
         }
      }
   }

   protected void generateClassFiles(RootDoc root, ClassTree classtree) throws DocletAbortException {
      ClassDoc[] classes = root.specifiedClasses();
      List incl = new ArrayList();

      for(int i = 0; i < classes.length; ++i) {
         ClassDoc cd = classes[i];
         if (cd.isIncluded()) {
            incl.add(cd);
         }
      }

      ClassDoc[] inclClasses = new ClassDoc[incl.size()];

      for(int i = 0; i < inclClasses.length; ++i) {
         inclClasses[i] = (ClassDoc)incl.get(i);
      }

      this.generateClassCycle(inclClasses, classtree, true);
      PackageDoc[] packages = configuration().packages;

      for(int i = 0; i < packages.length; ++i) {
         PackageDoc pkg = packages[i];
         this.generateClassCycle(pkg.interfaces(), classtree, false);
         this.generateClassCycle(pkg.ordinaryClasses(), classtree, false);
         this.generateClassCycle(pkg.exceptions(), classtree, false);
         this.generateClassCycle(pkg.errors(), classtree, false);
      }
   }

   public static int optionLength(String option) {
      return configuration().optionLength(option);
   }

   protected void performCopy(String configdestdir, String filename) throws DocletAbortException {
      try {
         String destdir = configdestdir.length() > 0 ? configdestdir + File.separatorChar : "";
         if (filename.length() > 0) {
            File helpstylefile = new File(filename);
            String parent = helpstylefile.getParent();
            String helpstylefilename = parent == null ? filename : filename.substring(parent.length() + 1);
            File desthelpfile = new File(destdir + helpstylefilename);
            if (!desthelpfile.getCanonicalPath().equals(helpstylefile.getCanonicalPath())) {
               configuration();
               ConfigurationStandard.standardmessage.notice("doclet.Copying_File_0_To_File_1", helpstylefile.toString(), desthelpfile.toString());
               copyFile(desthelpfile, helpstylefile);
            }
         }
      } catch (IOException var8) {
         configuration();
         ConfigurationStandard.standardmessage.error("doclet.perform_copy_exception_encountered", var8.toString());
         throw new DocletAbortException();
      }
   }

   public static boolean start(RootDoc root) throws IOException {
      try {
         configuration().setOptions(root);
         new Standard().startGeneration(root);
         return true;
      } catch (DocletAbortException var2) {
         var2.printStackTrace();
         return false;
      }
   }

   protected void startGeneration(RootDoc root) throws DocletAbortException {
      if (root.classes().length == 0) {
         configuration();
         ConfigurationStandard.standardmessage.notice("doclet.No_Public_Classes_To_Document");
      } else {
         String configdestdir = configuration().destdirname;
         String confighelpfile = configuration().helpfile;
         String configstylefile = configuration().stylesheetfile;
         boolean nodeprecated = configuration().nodeprecated;
         this.performCopy(configdestdir, confighelpfile);
         this.performCopy(configdestdir, configstylefile);
         ClassTree classtree = new ClassTree(root, nodeprecated);
         if (configuration().classuse) {
            ClassUseMapper.generate(root, classtree);
         }

         IndexBuilder indexbuilder = new IndexBuilder(root, nodeprecated);
         PackageDoc[] packages = configuration().packages;
         if (configuration().createtree) {
            TreeWriter.generate(classtree);
         }

         if (configuration().createindex) {
            if (configuration().splitindex) {
               SplitIndexWriter.generate(indexbuilder);
            } else {
               SingleIndexWriter.generate(indexbuilder);
            }
         }

         if (!configuration().nodeprecatedlist && !nodeprecated) {
            DeprecatedListWriter.generate(root);
         }

         AllClassesFrameWriter.generate(new IndexBuilder(root, nodeprecated, true));
         FrameOutputWriter.generate();
         PackagesFileWriter.generate();
         if (configuration().createoverview) {
            PackageIndexWriter.generate(root);
         }

         if (packages.length > 1) {
            PackageIndexFrameWriter.generate();
         }

         for(int i = 0; i < packages.length; ++i) {
            PackageDoc prev = i == 0 ? null : packages[i - 1];
            PackageDoc packagedoc = packages[i];
            PackageDoc next = i + 1 == packages.length ? null : packages[i + 1];
            PackageWriter.generate(packages[i], prev, next);
            PackageTreeWriter.generate(packages[i], prev, next, nodeprecated);
            PackageFrameWriter.generate(packages[i]);
         }

         this.generateClassFiles(root, classtree);
         SerializedFormWriter.generate(root);
         PackageListWriter.generate(root);
         HelpWriter.generate();
         StylesheetWriter.generate();
      }
   }

   public static boolean validOptions(String[][] options, DocErrorReporter reporter) throws IOException {
      return configuration().validOptions(options, reporter);
   }
}