package ru.emdev.EmForge.security;

import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.util.Random;

import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;

import org.acegisecurity.providers.encoding.PasswordEncoder;
import org.emforge.wiki.web.bean.Crumb;
import org.springframework.beans.factory.InitializingBean;

import ru.emdev.EmForge.email.EmailServices;
import ru.emdev.EmForge.messages.RegNotificationEmail;
import ru.emdev.EmForge.security.dao.Role;
import ru.emdev.EmForge.security.dao.User;
import ru.emdev.EmForge.security.dao.UserDao;
import ru.emdev.EmForge.security.web.SiteRole;
import ru.emdev.EmForge.util.RandomGUID;
import ru.emdev.EmForge.web.bean.BaseControllerImpl;
import ru.emdev.EmForge.web.bean.MainMenuController.MainMenuItem;

import com.octo.captcha.service.image.ImageCaptchaService;

/**
 * Controller, responsible for creation of new users
 */
public class RegisterController extends BaseControllerImpl implements InitializingBean {

    public static final String  PAGE_NAME  = "register.faces";
    public static final String  TITLE      = "Register New User";

    public static final String  CAPTCHA_ID = "EmForge";

    private UserDao             m_userDao;
    private PasswordEncoder     m_passwordEncoder;
    private EmailServices       m_emailServices;
    private ImageCaptchaService m_imageCaptchaService;

    private User                m_user;
    private String              m_password;
    private String              m_confirmPassword;
    private String              m_secureText;

    private Boolean             m_useActivation;
    private Boolean             m_assignWriterRole;

    public void setUserDao(UserDao i_userDao) {

        m_userDao = i_userDao;
    }

    public void setPasswordEncoder(PasswordEncoder i_passwordEncoder) {

        m_passwordEncoder = i_passwordEncoder;
    }

    public void setEmailServices(EmailServices i_emailServices) {

        m_emailServices = i_emailServices;
    }

    public void setUseActivation(Boolean i_useActivation) {

        m_useActivation = i_useActivation;
    }

    public Boolean getUseActivation() {

        return m_useActivation;
    }

    public void setAssignWriterRole(Boolean i_assignWriterRole) {

        m_assignWriterRole = i_assignWriterRole;
    }

    public Boolean getAssignWriterRole() {

        return m_assignWriterRole;
    }

    public void setImageCaptchaService(ImageCaptchaService i_imageCaptchaService) {

        m_imageCaptchaService = i_imageCaptchaService;
    }

    public void afterPropertiesSet() throws Exception {

        if (m_userDao == null) {
            throw new IllegalArgumentException(
                "userDao should be specified for Register Controller");
        }

        super.afterPropertiesSet();
    }

    @Override
    public MainMenuItem getSelectionItemOnMainMenu() {

        return MainMenuItem.TASKS;
    }

    @Override
    public String getTitleImpl() {

        return TITLE;
    }

    @Override
    public Crumb getTrailCrumbInfo() {

        return new Crumb(TITLE, PAGE_NAME);
    }

    @Override
    protected void init() {

        // create new user
        m_user = new User();
    }

    public User getUser() {

        return m_user;
    }

    public String getPassword() {

        return m_password;
    }

    public void setPassword(String i_password) {

        m_password = i_password;
    }

    public String getConfirmPassword() {

        return m_confirmPassword;
    }

    public void setConfirmPassword(String i_password) {

        m_confirmPassword = i_password;
    }

    public String getSecureText() {

        return m_secureText;
    }

    public void setSecureText(String i_secureText) {

        m_secureText = i_secureText;
    }

    protected BufferedImage generateCaptcha() {

        try {
            return m_imageCaptchaService.getImageChallengeForID(CAPTCHA_ID);
        } catch (Exception ex) {
            logger.error("Cannot generate captcha image", ex);
            return null;
        }
    }

    public int getCaptchaWidth() {

        return 250;
    }

    public int getCaptchaHeight() {

        return 100;
    }

    /**
     * Paints Captcha Image
     * 
     * @param g2d
     * @param obj
     */
    public void paintCaptcha(Graphics2D g2d, Object obj) {

        BufferedImage secureImage = generateCaptcha();

        try {
            g2d.setClip(0, 0, secureImage.getWidth(), secureImage.getHeight());
            g2d.drawImage(secureImage, 0, 0, null);
        } catch (Exception ex) {
            logger.error("Cannot generate captcha image", ex);
        }
    }

    /**
     * Performs Submit Action
     * 
     * @return
     */
    public String submit() {

        try {
            // encode password
            if (m_passwordEncoder != null) {
                m_user.setPassword(m_passwordEncoder.encodePassword(m_password, ""));
            }

            // Assign the user to default roles
            Role role = m_userDao.ensureRole(SiteRole.USER.getId());
            m_user.addRole(role);
            if (m_assignWriterRole) {
                role = m_userDao.ensureRole(SiteRole.WRITER.getId());
                m_user.addRole(role);
            }

            // now, generate activation code
            String activationCode = new RandomGUID().toString();

            if (m_useActivation) {
                m_user.setActivationCode(activationCode);
            } else {
                // activate user right here
                m_user.setActive(true);
            }

            try {
                // save user
                m_userDao.saveUser(m_user);
            } catch (Exception ex) {
                logger.error("Cannot store user", ex);
                addMessage("Cannot store user", ex.getMessage(), FacesMessage.SEVERITY_ERROR);
                return null;
            }

            if (m_useActivation) {
                // send email notification
                RegNotificationEmail message = (RegNotificationEmail) m_emailServices
                    .getEmailFactory().createEmail("regnotification");

                message.setNotificationCode(activationCode);
                message.setToName(m_user.getEmail());

                try {
                    m_emailServices.getEmailSender().sendMessage(message);
                } catch (Exception ex) {
                    logger.error("Cannot send registration notification email to "
                            + m_user.getEmail());
                    FacesContext context = FacesContext.getCurrentInstance();
                    FacesMessage fm = new FacesMessage(
                        "Cannot send registration notification email to " + m_user.getEmail(), null);
                    fm.setSeverity(FacesMessage.SEVERITY_ERROR);
                    context.addMessage(null, fm);
                    return null;
                }
            }

            return "success";
        } finally {
            // generate new secure text
            // generateCaptcha();
        }
    }

    /** Generates Random Text for displaying on the image */
    public String getRandomString() {

        String str = new String("QAa0bcLdUK2eHfJgTP8XhiFj61DOklNm9nBoI5pGqYVrs3CtSuMZvwWx4yE7zR");
        StringBuffer sb = new StringBuffer();
        Random r = new Random();
        int te = 0;
        for (int i = 1; i <= 6; i++) {
            te = r.nextInt(62);
            sb.append(str.charAt(te));
        }

        return sb.toString();
    }
}