package org.ogce.purse.impl;
   
   import java.util.Calendar;
   import java.util.Iterator;
   import java.util.Set;
   
   import org.apache.log4j.Logger;
   import org.globus.purse.registration.UserData;
   import org.gridlab.gridsphere.portlet.PortletGroup;
  import org.gridlab.gridsphere.portlet.PortletRequest;
  import org.gridlab.gridsphere.portlet.PortletRole;
  import org.gridlab.gridsphere.portlet.User;
  import org.gridlab.gridsphere.portlet.impl.SportletUser;
  import org.gridlab.gridsphere.portlet.service.PortletServiceNotFoundException;
  import org.gridlab.gridsphere.portlet.service.PortletServiceUnavailableException;
  import org.gridlab.gridsphere.portlet.service.spi.PortletServiceFactory;
  import org.gridlab.gridsphere.portlet.service.spi.impl.SportletServiceFactory;
  import org.gridlab.gridsphere.portlets.core.user.ProfileManagerPortlet;
  import org.gridlab.gridsphere.provider.event.FormEvent;
  import org.gridlab.gridsphere.services.core.portal.PortalConfigService;
  import org.gridlab.gridsphere.services.core.security.acl.AccessControlManagerService;
  import org.gridlab.gridsphere.services.core.security.acl.GroupRequest;
  import org.gridlab.gridsphere.services.core.security.password.InvalidPasswordException;
  import org.gridlab.gridsphere.services.core.security.password.PasswordEditor;
  import org.gridlab.gridsphere.services.core.security.password.PasswordManagerService;
  import org.gridlab.gridsphere.services.core.user.UserManagerService;
  import org.ogce.purse.api.PurseEvent;
  import org.ogce.purse.api.PurseEventException;
  import org.ogce.purse.api.RegistrationModule;
  
  public class GridSphereRegistrationModule implements RegistrationModule {
  
      private static final Logger log = Logger.getLogger(GridSphereRegistrationModule.class);
      private static GridSphereRegistrationModule module = null;
      private static UserManagerService userManagerService;
      private static PasswordManagerService passwordManagerService;
      private static PortalConfigService portalConfigService;
      private static AccessControlManagerService aclManagerService;
      
      private GridSphereRegistrationModule() {
          PortletServiceFactory serviceFactory = SportletServiceFactory.getInstance();
          try {
              userManagerService = (UserManagerService)
                  serviceFactory.createPortletService(UserManagerService.class, null, true);
              passwordManagerService = (PasswordManagerService)
                  serviceFactory.createPortletService(PasswordManagerService.class, null, true);
              portalConfigService = (PortalConfigService)
                  serviceFactory.createPortletService(PortalConfigService.class, null, true);
              aclManagerService = (AccessControlManagerService)
                  serviceFactory.createPortletService(AccessControlManagerService.class, null, true);
          } catch (PortletServiceNotFoundException e) {
              e.printStackTrace();
          } catch (PortletServiceUnavailableException e) {
              e.printStackTrace();
          }
      }
      public static GridSphereRegistrationModule getInstance() {
          if (module == null) {
              module = new GridSphereRegistrationModule();
          } 
          return module;
      }
  
      private void createUser(UserData user) {
          SportletUser newUser = userManagerService.createUser();
  
          // Edit account attributes
          newUser.setUserName(user.getUserName());
          newUser.setFullName(user.getFirstName() + " " + user.getLastName());
          newUser.setEmailAddress(user.getEmailAddress());
          newUser.setOrganization(user.getInstitution());
          userManagerService.saveUser(newUser);
          log.debug("Saved new user [" + newUser.getUserName() + "]");
          
          // Save password
          PasswordEditor editor = passwordManagerService.editPassword(newUser);
          editor.setValue(user.getPassword());
          editor.setDateLastModified(Calendar.getInstance().getTime());
          passwordManagerService.savePassword(editor);
          
          // Set default role and group
          Set groups = portalConfigService.getPortalConfigSettings().getDefaultGroups();
          Iterator it = groups.iterator();
          while (it.hasNext()) {
              PortletGroup group = (PortletGroup) it.next();
              GroupRequest groupRequest = aclManagerService.createGroupEntry();
              groupRequest.setUser(newUser);
              groupRequest.setGroup(group);
              groupRequest.setRole(aclManagerService.getRoleByName(PortletRole.USER.getName()));
  
              // Submit changes
              aclManagerService.saveGroupEntry(groupRequest);
          }
      }
  
      public void onEvent(PurseEvent event) throws PurseEventException {
          UserData userData = event.getUserData();
          switch (event.getEventType()) {
          case PurseEvent.CONFIRMED_EVENT:
         case PurseEvent.ACCEPTED_EVENT:
             if (! accountExists(userData.getUserName())) {
                 createUser(userData);
             }
             break;
         case PurseEvent.PASSWORD_UPDATED_EVENT:
             log.debug("Got a password update event");
             updatePassword(event);
         default:
             break;
         }
     }
     
     private void updatePassword(PurseEvent event) throws PurseEventException {
         boolean successful = false;
         UserData userData = event.getUserData();
         User user = userManagerService.getUserByUserName(userData.getUserName());
         String origPasswd = event.getOldPassword();
         try {
             passwordManagerService.validateSuppliedPassword(user, origPasswd);
             log.debug("Verified user password");
         } catch (InvalidPasswordException e) {
             log.error("Unable to verify GridSphere password", e);
             return;
         }
 
         String passwordValue = event.getNewPassword();
 
         if (passwordValue == null) {
             log.error("Old password is null");
         } else
         // Otherwise, password must match confirmation
         if (passwordValue.length() == 0) {
             log.error("Password is zero length");
         } else if (passwordValue.length() < 5) {
             log.error("Password is too short");
         } else {
             // save password
             PasswordEditor editPasswd = passwordManagerService.editPassword(user);
             editPasswd.setValue(passwordValue);
             editPasswd.setDateLastModified(Calendar.getInstance().getTime());
             passwordManagerService.savePassword(editPasswd);
             log.debug("Successfully saved new password");
             successful = true;
         }
         if (!successful) {
             throw new PurseEventException("Unable to update GridSphere password.");
         }
     }
     
     public String getName() {
         return "GridSphere";
     }
     public int getStatus(UserData userData) {
         if (accountExists(userData.getUserName())) {
             return RegistrationModule.STATUS_ACCOUNT_OK;
         } else {
             return RegistrationModule.STATUS_ACCOUNT_NONE;
         }
     }
     
     public boolean accountExists(String username) {
         return userManagerService.existsUserName(username);
     }
 
 }