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);

           }

         };

   }

 */

 }