package org.paneris.bibliomania;
   
   import java.util.Enumeration;
   import java.util.Vector;
   
   import org.melati.Melati;
   import org.melati.MelatiConfig;
   import org.melati.poem.AccessToken;
   import org.melati.poem.Field;
  import org.melati.poem.GroupMembership;
  import org.melati.poem.PoemThread;
  import org.melati.template.TemplateContext;
  import org.melati.template.TemplateEngine;
  import org.melati.util.Email;
  import org.melati.poem.util.EnumUtils;
  import org.melati.poem.util.MappedEnumeration;
  import org.melati.util.MelatiStringWriter;
  import org.melati.poem.util.StringUtils;
  import org.melati.util.UnexpectedExceptionException;
  import org.paneris.bibliomania.generated.UserBase;
  
  public class User extends UserBase {
    
    TemplateEngine templateEngine = null;
    MelatiConfig config = null;
    Melati myMelati = null;
    
    public BibliomaniaDatabase getBibliomaniaDatabase () {
        return (BibliomaniaDatabase)getDatabase();
    }
  
    public User() {}
  
    public void postInsert() {
      if (getBibliomaniaDatabase().getRegisteredUserGroup() != null) {
        GroupMembership membership = (GroupMembership)getBibliomaniaDatabase().getGroupMembershipTable().newPersistent();
        membership.setUser(this);
        membership.setGroup(getBibliomaniaDatabase().getRegisteredUserGroup());
        getBibliomaniaDatabase().getGroupMembershipTable().create(membership);
      }
      // email the user
      if (this != getUserTable().administratorUser() &&
          this != getUserTable().guestUser() && 
          this != ((UserTable)getUserTable()).boardManager() &&
          false) //FIXME Sometime
        
        try {
          if (templateEngine == null) {
            config = new MelatiConfig();
            templateEngine = config.getTemplateEngine();
            templateEngine.init(config);
            myMelati = new Melati(config,null);
            myMelati.setTemplateEngine(templateEngine);
          }
          TemplateContext context = templateEngine.getTemplateContext();
          context.put("melati",myMelati);
          context.put("user",this);
          String templateName = "org/paneris/bibliomania/html/email/NewUser.wm";
          MelatiStringWriter sw = (MelatiStringWriter)myMelati.getStringWriter();
          templateEngine.expandTemplate(sw, templateName, context);
          myMelati.write();
          String message = sw.toString();
          Email.send(getDatabase().getSettingTable().get(Email.SMTPSERVER), getBibliomaniaDatabase().getConfirmationEmailFrom(), 
                     getEmail(), "", "Bibliomania registration details", message);
        } catch (Exception e) {
          throw new UnexpectedExceptionException("A confirmation email could not be sent",e);
        }
    }
    
    // if a user is auto created by mailing a messageboard, assume they want
    // to be spammed
    public void generateDefaults() {
      super.generateDefaults();
      if (getWantemailalerts() == null) setWantemailalerts(Boolean.TRUE);
      if (getWantspam() == null) setWantspam(Boolean.TRUE);
      if (getFulltimeeducation() == null) setFulltimeeducation(Boolean.FALSE);
      if (getDodgeyemail() == null) setDodgeyemail(Boolean.FALSE);
    }
  
    public void assertCanRead(AccessToken token) {
      if (token != this)
        super.assertCanRead(token);
    }
  
    public void assertCanWrite(AccessToken token) {
      if (token != this && this != getDatabase().guestAccessToken())
        super.assertCanWrite(token);
    }
    
   public boolean hasPurchased(Download download) {
      return hasPurchased(download.getTroid());
   }
   
   public boolean hasPurchased(Integer troid) {
      Vector where = new Vector();
      where.add("\"user\" = " + getTroid()); 
      where.add("authorised = true"); 
      where.add("product = product.id"); 
      where.add("product.download = " + troid); 
     String whereClause = EnumUtils.concatenated(" AND ", where.elements());
     return getBibliomaniaDatabase().getShopOrderItemTable().troidSelection(whereClause, null, false).hasMoreElements();
  }
   
   public boolean isRegisteredUser(BibliomaniaDatabase db) {
     return PoemThread.accessToken().givesCapability(db.getRegisteredUserCapability());
   }
   
     
   public String generateName() {
     String generatedName = getEmail();
     // ahhh - still none - randomise
     if (generatedName == null  || generatedName.equals("")) return StringUtils.randomString(6);
     // try and make the best of it if we have a name that is actually an email address
     int at = generatedName.indexOf('@');
     int dot = generatedName.indexOf('.');
     if (dot != -1 && dot < at) at = dot;
     if (at > 0) generatedName = generatedName.substring(0,at);
     return generatedName;
   }
     
   public String generateLogin() {
     return getEmail();
   }
     
   public String generatePassword() {
     return StringUtils.randomString(6);
   }  
   
   public Enumeration getUserDetailsFields() {
     return
       new MappedEnumeration(fieldsOfColumns(((org.paneris.bibliomania.UserTable)
                             getUserTable()).getUserDetailsColumns())) {
         public Object mapped(Object field) {
           Field f = (Field)field;
           if (f.getName().equals("name")) 
             return f.withDescription("Your name");
           if (f.getName().equals("email")) 
             return f.withDescription("Your email address");
           if (f.getName().equals("password")) 
             return f.withDescription("Your password");
           return f;
           }
         };
   }
 /*
    // this is now in Column.java
   public Enumeration fieldsOfColumns(Enumeration columns) {
     // return new FieldsEnumeration(this, columns);
     final Persistent _this = this;
     return
         new MappedEnumeration(columns) {
           public Object mapped(Object column) {
             return ((Column)column).asField(_this);
           }
         };
   }
 */
 }