package org.legrog.entities;

import javax.persistence.*;
import java.util.*;
// TODO Evaluer l'interet de cet import
//import org.roliste.data.DbValidationEntity;

// TODO Vérifier les extends
/*
    Entité persistante représentant un utilisateur.
    Migréee depuis la v2.
 */
@Entity
public class Account /* extends org.roliste.data.DbTraceableEntity */ implements DisplayNameConfigurable /*, DbValidationEntity */ {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int userId;

    // TODO traiter Traceable
    /**
     * Retrieve this object's Traceable.
     * @hibernate.many-to-one
     * 		column="ID_JOURNALISABLE"
     * 		class="org.roliste.data.db.Traceable"
     *  	access="property"
     *  	lazy="false"
     *      cascade="all"
     *      foreign-key="FK_THEME_JOURNALISABLE"
     * @return the {@link org.roliste.data.db.Traceable} record corresponding to this object. May be <code>null</code>.
     * @see #setTraceable(org.roliste.data.db.Traceable)
     */
    /*
    public Traceable getTraceable()
    {
        return _traceRoot;
    }
*/

    /**
     * The mask used for account name.
     */
    private DisplayNameMask displayNameMask;
/*
    @Override
    public String getUrlKey()
    {
        return "/utilisateurs/" + getScreenName();
    }
*/
    /**
     * @return the account's name as desired. By default, return the complete name.
     * see org.roliste.data.db.NameMask#mask(org.roliste.data.DbMaskableEntity)
     */
    public String getDisplayName()
    {
        if (displayNameMask != null)
            return displayNameMask.getDisplayName(this);
        else
            return DisplayNameMask.COMPLET.getDisplayName(this);
    }

    /**
     * Returns the account's name mask.
     * @return the mask.
     * see #setNameMask(NameMask)
     * hibernate.property
     *  	column="MASQUE_NOM_UTILISATEUR"
     *  	access="property"
     *  	length="50"
     * hibernate.type
     *      name="org.roliste.data.util.NameMaskUserType"
     */
    public DisplayNameMask getDisplayNameMask() {
        return displayNameMask;
    }

    /**
     * Initializes the account's name mask.
     * @param mask the new {link org.roliste.data.db.NameMask}.
     * see #getNameMask()
     */
    public void setDisplayNameMask(DisplayNameMask mask) {
        this.displayNameMask = mask;
    }


            // TODO Faire ailleurs les contrôles de chaîne vide sur : username, password, firstname, lastname, nickname, email, text
    /**
     * The account identifier.
     */
    private String username;

    /**
     * The account password.
     */
    private String password;

    /**
     * The account first name.
     */
    private String firstName;

    /**
     * The account last name.
     */
    private String lastName;

    /**
     * The account nick name.
     */
    private String nickname;

    /**
     * The account email address.
     */
    private String email;

    /**
     * The {link org.roliste.data.db.AccountRole}s for this account.
     */
    @ManyToMany(fetch = FetchType.EAGER)
    private List<AccountRole> roles;

    /**
     * Retrieves the list of {@link AccountRole}s for this account.
     * SHALL be used as a read-only attribute. In particular, avoid
     * using {@link List#add(Object)} or {@link List#remove(Object)} on
     * the returned value without caution.
     * @return a {@link List} of {@link AccountRole}. Shall not be <code>null</code>.
     * @see #setRoles(List)
     * see #addToRole(AccountRole)
     * see #removeFromRole(AccountRole)
     * hibernate.many-to-many
     *  	column="ROLE_FK"
     *  	class="org.roliste.data.db.AccountRole"
     *      foreign-key="FK_UTILISATEURROLE_ROLEUTILISATEUR"
     * @hibernate.key
     * 		column="UTILISATEUR_FK"
     * 		not-null="true"
     *      foreign-key="FK_UTILISATEURROLE_UTILISATEUR"
     * @hibernate.bag
     * 		cascade="save-update"
     * 		access="property"
     * 		table="role_utilisateur"
     * 		lazy="true"
     */

    public List<AccountRole> getRoles() {
        return roles;
    }

    /**
     * Lists the list of {@link AccountRole}s for this account.
     * @param roles the new {@link List} of {@link AccountRole}s. Shall not be <code>null</code>.
     * @throws NullPointerException if roles is <code>null</code>.
     * @see #getRoles()
     * see #addToRole(AccountRole)
     * see #removeFromRole(AccountRole)
     */

    public void setRoles(List<AccountRole> roles) {
        if (roles == null)
        {
            throw new NullPointerException("Impossible d'affecter un ensemble nul aux r�les d'un utilisateur");
        }
        this.roles = roles;
    }

    /**
     * Add the account to a given {@link AccountRole}s.
     * @param role the new {@link AccountRole}. Ignored if <code>null</code>.
     * @see #getRoles()
     * @see #setRoles(List)
     * @see #removeFromRole(AccountRole)
     */
    /*
    public void addToRole(AccountRole role) {
        synchronized (this)
        {
            if ((role != null) && !(getRoles().contains(role)) )
            {
                role.getAccounts().add(this);
                getRoles().add(role);
            }
        }
    }
*/
    /**
     * Remove the account from a given {@link AccountRole}s.
     * @param role the {@link AccountRole} this {@link Account} will lose. Ignored if <code>null</code>.
     * @see #getRoles()
     * @see #setRoles(List)
     * @see #addToRole(AccountRole)
     */
    /*
    public void removeFromRole(AccountRole role) {
        synchronized (this)
        {
            if ((role != null) && (getRoles().contains(role)) )
            {
                role.getAccounts().remove(this);
                getRoles().remove(role);
            }
        }
    }
*/
    /**
     * The account anonymous status.
     * If anonymous, account cannot be contacted through email.
     */
    private boolean anonymous;

    /**
     * The account validation status.
     */
    private boolean visible;

    /**
     * The account was activated at least once.
     */
    private boolean activated;

    /**
     * The account provides critics for archive.
     */
    private boolean criticProvider;

    /**
     * Presentation text.
     */
    @Lob
    private String presentation;

    /**
     * The {@link org.roliste.data.db.BookDetails}s in this account's collection.
     */
//    private List<BookDetails> _collection;

    /**
     * Retrieves the list of {@link org.roliste.data.db.BookDetails}s in this account's collection.
     * SHALL be used as a read-only attribute. In particular, avoid using {@link List#add(Object)}
     * or {@link List#remove(Object)} on the returned value without caution.
     * @return a {@link List} of {@link org.roliste.data.db.BookDetails}. Shall not be <code>null</code>.
     * @see #setCollection(List)
     * @see #addToCollection(BookDetails)
     * @see #removeFromCollection(BookDetails)
     * @hibernate.many-to-many
     *  	column="DETAILS_FK"
     *  	class="org.roliste.data.db.BookDetails"
     *      foreign-key="FK_COLLECTION_DETAIL"
     * @hibernate.key
     * 		column="UTILISATEUR_FK"
     * 		not-null="true"
     *      foreign-key="FK_COLLECTION_UTILISATEUR"
     * @hibernate.bag
     * 		access="property"
     * 		table="collection"
     * 		lazy="true"
     */
    /*
    public List<BookDetails> getCollection() {
        return _collection;
    }
*/
    /**
     * Lists the list of {@link org.roliste.data.db.BookDetails}s in this account's collection.
     * @param collec the new {@link List} of {@link org.roliste.data.db.BookDetails}s. Shall not be <code>null</code>.
     * @throws NullPointerException if collec is <code>null</code>.
     * @see #getCollection()
     * @see #addToCollection(BookDetails)
     * @see #removeFromCollection(BookDetails)
     */
    /*
    public void setCollection(List<BookDetails> collec) {
        if (collec == null)
        {
            throw new NullPointerException("Impossible d'affecter un ensemble nul pour la collection d'un utilisateur");
        }
        _collection = collec;
    }
*/
    /**
     * Add a book to the account's collection.
     * @param book the new {@link org.roliste.data.db.BookDetails}. Ignored if <code>null</code>.
     * @see #getCollection()
     * @see #setCollection(List)
     * @see #removeFromCollection(BookDetails)
     */
    /*
    public void addToCollection(BookDetails book) {
        synchronized (this)
        {
            if ((book != null) && !(getCollection().contains(book)) )
            {
                book.getOwners().add(this);
                getCollection().add(book);
            }
        }
    }
*/
    /**
     * Remove a book from account's collection.
     * @param book the {@link org.roliste.data.db.BookDetails} this {@link Account} will lose. Ignored if <code>null</code>.
     * @see #getCollection()
     * @see #setCollection(List)
     * @see #addToCollection(BookDetails)
     */
    /*
    public void removeFromCollection(BookDetails book) {
        synchronized (this)
        {
            if ((book != null) && (getCollection().contains(book)) )
            {
                book.getOwners().remove(this);
                getCollection().remove(book);
            }
        }
    }
*/
    /**
     * The {@link org.roliste.data.db.Traceable}s delegated to this account.
     */
//    private List<Traceable> _delegations;

    /**
     * Retrieves the list of delegations for this account.
     * Each delegation is a link to a {@link org.roliste.data.db.Traceable} object.
     * A account having delegation may update field values for delegated object.
     * @return a {@link List} of {@link AccountRole}. Shall not be <code>null</code>. SHALL be used as a
     * read-only attribute. In particular, avoid using {@link List#add(Object)} or {@link List#remove(Object)}
     * on the returned value without caution.
     * @see #setDelegations(List)
     * @see #giveDelegation(Traceable)
     * @see #removeDelegation(Traceable)
     * @hibernate.many-to-many
     *  	column="ID_JOURNALISABLE"
     *  	class="org.roliste.data.db.Traceable"
     *      foreign-key="FK_DELEGATION_JOURNALISABLE"
     * @hibernate.key
     * 		column="ID_UTILISATEUR"
     * 		not-null="true"
     *      foreign-key="FK_DELEGATION_UTILISATEUR"
     * @hibernate.bag
     * 		cascade="save-update"
     * 		access="property"
     * 		table="delegation_utilisateur"
     * 		lazy="true"
     */
    /*
    public List<Traceable> getDelegations() {
        return _delegations;
    }
*/
    /**
     * Sets the list of delegations for this account.
     * @param objects the new {@link List} of delegated {@link Traceable}. Shall not be <code>null</code>.
     * @throws NullPointerException if objects is <code>null</code>.
     * @see #getDelegations()
     * @see #giveDelegation(Traceable)
     * @see #removeDelegation(Traceable)
     */
    /*
    public void setDelegations(List<Traceable> objects) {
        if (_delegations == null)
        {
            throw new NullPointerException("Impossible d'affecter un ensemble nul aux d�l�gations d'un utilisateur");
        }
        _delegations = objects;
    }
*/
    /**
     * Give delegation on a given {@link Traceable} to this account.
     * @param object the new delegation. Ignored if <code>null</code>.
     * @see #getDelegations()
     * @see #setDelegations(List)
     * @see #removeDelegation(Traceable)
     */
    /*
    public void giveDelegation(Traceable object) {
        synchronized (this)
        {
            if ((object != null) && !(getDelegations().contains(object)) )
            {
                object.getDelegates().add(this);
                getDelegations().add(object);
            }
        }
    }
*/
    /**
     * Remove delegation on a given {@link Traceable} from this account.
     * @param object the delegation this {@link Account} will lose. Ignored if <code>null</code>.
     * @see #getDelegations()
     * @see #setDelegations(List)
     * @see #giveDelegation(Traceable)
     */
    /*
    public void removeDelegation(Traceable object) {
        synchronized (this)
        {
            if ((object != null) && (getDelegations().contains(object)) )
            {
                object.getDelegates().remove(this);
                getDelegations().remove(object);
            }
        }
    }
*/
    /**
     * Clear all delegations for this account.
     */
    /*
    public void clearDelegations()
    {
        synchronized (this)
        {
            for (Traceable root : getDelegations())
            {
                root.getDelegates().remove(this);
            }
            getDelegations().clear();
        }
    }
*/
    /**
     * The list of attributes / properties for this account.
     */
    @OneToMany(mappedBy = "account")
    private List<AccountAttribute> accountAttributes;

    /**
     * Retrieve this account's attributes.
     * @hibernate.one-to-many
     * 		class="org.roliste.data.db.AccountAttribute"
     * @hibernate.bag
     *      cascade="all"
     *      lazy="true"
     *      inverse="true"
     * @hibernate.key
     *      column="ID_UTILISATEUR"
     * @return a {@link java.util.List} of account attributes linked to this. Shall not be <code>null</code>.
     * @see #setAttributes(java.util.List)
     */

    public List<AccountAttribute> getAttributes()
    {
        return accountAttributes;
    }

    /**
     * @param attribs the List of attributes for this account.
     * @see #getAttributes()
     */

    public void setAttributes(List<AccountAttribute> attribs)
    {
        this.accountAttributes = attribs;
    }

    /**
     * The {@link org.roliste.data.db.GamingEvent}s this account's visited.
     */
//    private Set<GamingEvent> _visitedEvents = new HashSet<GamingEvent>();

    /**
     * Retrieves the list of {@link GamingEvent}s visited by this account.
     * SHALL be used as a read-only attribute. In particular, avoid
     * using {@link Set#add(Object)} or {@link Set#remove(Object)} on
     * the returned value without caution.
     * @return a {@link Set} of {@link GamingEvent}s. May be <code>null</code>.
     * @see #setVisitedEvents(Set)
     * @hibernate.many-to-many
     *  	column="MANIF_FK"
     *  	class="org.roliste.data.db.GamingEvent"
     * @hibernate.key
     * 		column="UTILISATEUR_FK"
     * 		not-null="true"
     * @hibernate.set
     * 		access="property"
     * 		table="manif_utilisateur"
     *		inverse="true"
     *		lazy="true"
     */
    /*
    public Set<GamingEvent> getVisitedEvents() {
        return _visitedEvents;
    }
*/
    /**
     * Sets the list of {link GamingEvent}s for this account.
     * param events the new {@link Set} of {link GamingEvent}s. May be
     * <code>null</code> (we don't handle the relation from this side).
     * see #getVisitedEvents()
     */
    /*
    protected void setVisitedEvents(Set<GamingEvent> events) {
        _visitedEvents = events;
    }
*/

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    /**
     * Returns the account identifier.
     * @return the {@link String} identifier.
     * @see #setUsername(String)
     * hibernate.property
     *  	column="LOGIN_UTILISATEUR"
     *  	not-null="true"
     *  	unique="true"
     *  	access="property"
     *  	length="50"
     */
    public String getUsername() {
        return username;
    }

    /**
     * Initializes the account identifier.
     * @param name the new {@link String} identifier.
     * @see #getUsername()
     */
    public void setUsername(String name) {
        this.username = name;
    }
    /**
     * Returns the account password.
     * @return the {@link String} password.
     * @see #setPassword(String)
     * hibernate.property
     *  	column="PASS_UTILISATEUR"
     *  	not-null="true"
     *  	access="property"
     *  	length="50"
     */
    public String getPassword() {
        return password;
    }

    /**
     * Initializes the account password.
     * @param pwd the new {@link String} password.
     * @see #getPassword()
     */
    public void setPassword(String pwd) {
        this.password = pwd;
    }

    /**
     * Returns the account full first name.
     * @return the {@link String} first name.
     * @see #setFirstName(String)
     * hibernate.property
     *  	column="PRENOM_UTILISATEUR"
     *  	not-null="true"
     *  	access="property"
     *  	length="50"
     */
    public String getFirstName() {
        return firstName;
    }

    /**
     * Initializes the account first name.
     * @param name the new {@link String} first name.
     * @see #getFirstName()
     */
    public void setFirstName(String name) {
        this.firstName = name;
    }

    /**
     * Returns the account full last name.
     * @return the {@link String} last name.
     * @see #setLastName(String)
     * hibernate.property
     *  	column="NOM_UTILISATEUR"
     *  	not-null="true"
     *  	access="property"
     *  	length="50"
     */
    public String getLastName() {
        return lastName;
    }

    /**
     * Initializes the account last name.
     * @param name the new {@link String} last name.
     * @see #getLastName()
     */
    public void setLastName(String name) {
        this.lastName = name;
    }

    /**
     * Returns the account full screen name.
     * @return the {@link String} screen name.
     * @see #setNickName(String)
     * hibernate.property
     *  	column="PSEUDO_UTILISATEUR"
     *  	access="property"
     *  	length="50"
     */
    public String getNickName() {
        return nickname;
    }

    /**
     * Initializes the account screen name.
     * @param name the new {@link String} screen name.
     * @see #getNickName()
     */
    public void setNickName(String name) {
        this.nickname = name;
    }

    /**
     * Returns the account email.
     * @return the {@link String} email.
     * @see #setEmail(String)
     * hibernate.property
     *  	column="EMAIL_UTILISATEUR"
     *  	unique="true"
     *      not-null="true"
     *  	access="property"
     *  	length="100"
     */
    public String getEmail() {
        return email;
    }

    /**
     * Initializes the account email.
     * @param address the new {@link String} email.
     * @see #getEmail()
     */
    public void setEmail(String address) {
        this.email = address;
    }

    /**
     * Indicates if the account is anonymous.
     * Anonymous users' email and first/last name won't be shown.
     * @return the anonymous flag.
     * @see #setAnonymous(boolean)
     * hibernate.property
     *  	column="IND_ANONYME"
     *  	access="property"
     */
    public boolean isAnonymous() {
        return anonymous;
    }

    /**
     * Initializes the account anonymous flag.
     * @param anonymous the new flag value.
     * @see #isAnonymous
     */
    public void setAnonymous(boolean anonymous) {
        this.anonymous = anonymous;
    }

    /**
     * hibernate.property
     *  	column="IND_VISIBLE"
     *  	access="property"
     */
    public boolean isVisible() {
        // WARNING: Method documentation copied from DbValidationEntity
        return visible;
    }

    public void setVisible(boolean visible) {
        // WARNING: Method documentation copied from DbValidationEntity
        this.visible = visible;
    }

    /**
     * Indicates if the account was activated at least once.
     * @return the activation flag.
     * @see #setCriticProvider(boolean)
     * hibernate.property
     *  	column="IND_ACTIVE"
     *  	access="property"
     */
    public boolean isActivated() {
        return activated;
    }

    /**
     * Initializes the account activation flag.
     * @param active the new flag value.
     * @see #isActivated
     */
    public void setActivated(boolean active) {
        this.activated = active;
    }

    /**
     * Indicates if the account provides critics for archives.
     * @return the critics provider flag.
     * @see #setCriticProvider(boolean)
     * hibernate.property
     *  	column="IND_CRITIQUES"
     *  	access="property"
     */
    public boolean isCriticProvider() {
        return criticProvider;
    }

    /**
     * Initializes the critics provider flag.
     * @param flag the new flag value.
     * @see #isCriticProvider
     */
    public void setCriticProvider(boolean flag) {
        this.criticProvider = flag;
    }

    /**
     * Returns the HTML text presentation for this account.
     * @return the {@link String} HTML text.
     * @see #setPresentation(String)
     * hibernate.property
     *  	column="PRESENTATION"
     *  	access="property"
     *      type="text"
     *      length="2147483647"
     */
    public String getPresentation() {
        return presentation;
    }

    /**
     * Initializes the HTML text presentation.
     * @param presentation the new {@link String} HTML text.
     * @see #getPresentation()
     */
    public void setPresentation(String presentation) {
        this.presentation = presentation;
    }

    /**
     * The account submission date.
     */
    private Date creationDate;

    /**
     * Returns this object creation {@link Date}.
     * @return the object creation {@link Date}.
     * @see #setCreationDate(Date)
     * hibernate.property
     *  	column="DATE_ENREGISTREMENT"
     *  	access="property"
     */
    public Date getCreationDate() {
        return creationDate;
    }

    /**
     * Initializes the object creation {@link Date}.
     * @param date the new object creation {@link Date}.
     * @see #getCreationDate()
     */
    public void setCreationDate(Date date) {
        this.creationDate = date;
    }

    @Override
    public String toString()
    {
        return "ID_UTILISATEUR=" + userId + " LOGIN_UTILISATEUR=" + username + " EMAIL_UTILISATEUR=" + email +
                " PRENOM_UTILISATEUR=" + firstName + " NOM_UTILISATEUR=" + lastName + " PSEUDO_UTILISATEUR=" + nickname;
    }
}