package org.paneris.bibliomania;
   
   import java.io.ByteArrayInputStream;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.util.Enumeration;
   import java.util.Hashtable;
  
  import org.melati.Melati;
  import org.melati.admin.AdminSpecialised;
  import org.melati.poem.CachedSelection;
  import org.melati.poem.PoemThread;
  import org.melati.poem.Table;
  import org.melati.poem.util.ArrayUtils;
  import org.melati.poem.util.EmptyEnumeration;
  import org.melati.poem.Treeable;
  import org.melati.template.MarkupLanguage;
  import org.paneris.bibliomania.fti.FTIException;
  import org.paneris.bibliomania.fti.Text;
  import org.paneris.bibliomania.generated.AuthorBase;
  
  public class Author extends AuthorBase implements AdminSpecialised, Text {
  
    public Author() {
    }
  
    public Author(String displayname) {
      this.displayname = displayname;
    }
  
    public String getLongname() {
      String it = getLongnameifdifferent();
      return it == null ? getDisplayname() : it;
    }
  
    public String getSortOrShortName() {
      String it = getSortname();
      return it == null ? getDisplayname() : it;
    }
  
    int firstFreeAuthorsequence() {
      return getBibliomaniaDatabase()
        .getBookTable()
        .getAuthorsequenceColumn()
        .firstFree("author = " + troid());
    }
  
    public Enumeration getBooks() {
      return getBibliomaniaDatabase()
        .getBookTable()
        .getAuthorColumn()
        .cachedSelectionWhereEq(this.troid()).objects();
    }
  
    public Enumeration getBooksOrderedBySection() {
      return getBibliomaniaDatabase().getBookTable().selection(
        "author=" + this.troid(),
        "section",
        false);
    }
  
    public Enumeration getMembersSlowly() {
      return getBooks();
    }
  
    public Enumeration getProductAssociations() {
      return getProductAssociations(
        getBibliomaniaDatabaseTables()
          .getProductAssociationTable()
          .getAuthorColumn());
    }
  
    private Hashtable booksInSection = null;
  
    public Enumeration booksInSection(Section sectionP) {
      if (booksInSection == null)
        booksInSection = new Hashtable();
  
      CachedSelection books = (CachedSelection)booksInSection.get(sectionP);
  
      if (books == null)
        booksInSection.put(
          sectionP,
          books =
            new CachedSelection(
              getBibliomaniaDatabase().getBookTable(),
              "author = " + troid() + " AND section = " + sectionP.troid(),
              null));
      System.err.println(books.toString());
      return books.objects();
    }
  
    private Hashtable<SectionGroup, CachedSelection<Book>> booksInSectionGroup = null;
  
    public Enumeration<Book> booksInSectionGroup(SectionGroup sectionGroup) {
      if (booksInSectionGroup == null)
        booksInSectionGroup = new Hashtable<SectionGroup, CachedSelection<Book>>();
 
     CachedSelection<Book> books = booksInSectionGroup.get(sectionGroup);
 
     if (books == null)
       booksInSectionGroup.put(
         sectionGroup,
         books =
           new CachedSelection(
               getBibliomaniaDatabase().getBookTable(),
               getBibliomaniaDatabase().getBookTable().getAuthorColumn().fullQuotedName() +
               " = "
               + troid()
               + " AND " + 
               getBibliomaniaDatabase().getSectionTable().troidColumn().fullQuotedName() +
               " = " + 
               getBibliomaniaDatabase().getBookTable().getSectionColumn().fullQuotedName() +
               " AND " +
               getBibliomaniaDatabase().getSectionTable().getGroupColumn().fullQuotedName() +
               " = "
               + sectionGroup.troid(),
             null,
             new Table[] { getBibliomaniaDatabase().getSectionTable()}));
 
     return books.objects();
   }
 
   public long ftiTextID() {
     return ftiTextID_start() | ((1L << Chapter.ftiTextID_author_shift) - 1);
   }
 
   public InputStream body() throws IOException {
     File f = getFrontPageFile();
     if (f.exists()) {
       InputStream it = new FileInputStream(f);
       PoemThread.toTidy().add(it);
       return it;
     } else
       return new ByteArrayInputStream(new byte[0]);
   }
 
   public InputStream bodyForFragment() throws IOException {
     return body();
   }
 
   public long ftiTextID_start() {
     Integer sectionTroid = getSectionTroid();
     return Chapter.ftiTextID(
       sectionTroid == null ? 0 : sectionTroid.intValue(),
       troid().intValue(),
       0,
       0);
   }
 
   public long ftiTextID_limit() {
     return ftiTextID_start() + (1L << Chapter.ftiTextID_author_shift);
   }
 
   public Unit getParentUnit() {
     return getSection();
   }
 
   public void appendCacheSubpath(StringBuffer buffer) {
     buffer.append("/a/");
     buffer.append(troid());
   }
 
   public String getDisplayName() {
     return getLongname();
   }
 
   public static final String frontPageFileName = "index.html";
 
   public File getFrontPageFile() {
     return new File(getCachePath(), frontPageFileName);
   }
 
   public void index() throws IOException {
     try {
       getBibliomaniaDatabase().infoFTI().index(this);
     } catch (IOException e) {
       throw e;
     } catch (Exception e) {
       throw new FTIException(e);
     }
   }
 
   public void encache() throws Exception {
     super.encache();
 
     Boolean nonstandardL = getNonstandard();
     if (nonstandardL == null || !nonstandardL.booleanValue())
       getBibliomaniaDatabase().interpolateTemplateToFile(
         "read/Author.wm",
         getFrontPageFile(),
         this);
   }
 
   public String getImageURL() {
     String imagefilenameL = getImagefilename();
     return imagefilenameL == null
       ? null
       : getBibliomaniaDatabase().getContentStaticRootURL()
         + new File(getPath() + "/" + imagefilenameL).toString();
   }
 
   private CachedSelection links = null;
 
   public Enumeration getLinks() {
     if (getTroid() == null)
       return new EmptyEnumeration();
     else {
       links =
         getBibliomaniaDatabase()
           .getAuthorWebSiteTable()
           .getAuthorColumn()
           .cachedSelectionWhereEq(getTroid());
         
       return links.objects();
     }
   }
 
   public Enumeration getCurrentLinks() { 
     getBibliomaniaDatabase().getAuthorWebSiteTable().ensure(
         this,
         "http://en.wikipedia.org/wiki/"+getDisplayName().replace(' ','_'),
         getDisplayName() + " on WikiPedia", 
         "");
     Enumeration<Object> l = getLinks();
     while(l.hasMoreElements()) { 
       AuthorWebSite aws = (AuthorWebSite)l.nextElement();
       if (!aws.isStillLive()) 
         aws.delete();
     }
     return getLinks();
   }
   public String adminHandle(Melati melati, MarkupLanguage markupLanguage)
     throws Exception {
     return null;
   }
 
   public String adminSpecialFacilities(
     Melati melati,
     MarkupLanguage markupLanguage)
     throws Exception {
     //    return (String)markupLanguage.templet("Author-specials");
     return getBibliomaniaDatabase().getWMTemplet("Author-specials");
   }
 
   public SectionGroup getReadArea() {
     Section sectionL = getSection();
     return sectionL != null
       ? sectionL.getReadArea()
       : getBibliomaniaDatabase().getReadSectionGroup();
   }
   
   /* 
    * @see org.melati.util.Treeable#getChildren()
    */
 
   public Treeable[] children = null;
 
   public Treeable[] getChildren() {
     if (children == null) {
       Object[] kids = ArrayUtils.arrayOf(getBooks());
       children = new Treeable[kids.length];
       for (int i=0; i<kids.length; i++) {
         children[i] = (Treeable)kids[i];
       }
     }
     return children;
   }
   /* 
    * @see org.melati.util.Treeable#getName()
    */
   public String getName() {
     return getDisplayName();
   }
 
 }