package net.ihe.xcpd.resp.model;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Query;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

import net.ihe.gazelle.simulator.common.model.Message;
import net.ihe.gazelle.simulator.common.utils.AndOrWhere;

import org.hibernate.validator.NotNull;
import org.jboss.seam.Component;
import org.jboss.seam.annotations.Logger;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.log.Log;

/**
 * @author Abderrazek Boufahja > INRIA Rennes IHE development Project
 *
 */
@Entity
@Name("messageUser")
@Table(name = "message_user", schema = "public")
@SequenceGenerator(name = "message_user_sequence", sequenceName = "message_user_id_seq", allocationSize = 1)
public class MessageUser  implements Serializable{
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    @Logger
    private static Log log;

    @Id
    @Column(name = "id", unique = true, nullable = false)
    @NotNull
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "message_user_sequence")
    private Integer id;
    
    @ManyToOne
    @JoinColumn(name = "message_id")
    private Message message;
    
    @Column(name = "ip")
    private String ip;
    
    @ManyToOne
    @JoinColumn(name = "ip_to_country_id")
    private IpToCountry ipToCountry;
    
    public MessageUser(){
    }

    public MessageUser(Message message, String ip, IpToCountry ipToCountry) {
        super();
        this.message = message;
        this.ip = ip;
        this.ipToCountry = ipToCountry;
    }
    
    public MessageUser(MessageUser mu){
        if (mu.message != null) this.message = mu.message;
        if (mu.ip != null) this.ip = mu.ip;
        if (mu.ipToCountry != null) this.ipToCountry = mu.ipToCountry;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Message getMessage() {
        return message;
    }

    public void setMessage(Message message) {
        this.message = message;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public IpToCountry getIpToCountry() {
        return ipToCountry;
    }

    public void setIpToCountry(IpToCountry ipToCountry) {
        this.ipToCountry = ipToCountry;
    }

    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((ip == null) ? 0 : ip.hashCode());
        result = prime * result
                + ((ipToCountry == null) ? 0 : ipToCountry.hashCode());
        result = prime * result + ((message == null) ? 0 : message.hashCode());
        return result;
    }

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        MessageUser other = (MessageUser) obj;
        if (ip == null) {
            if (other.ip != null)
                return false;
        } else if (!ip.equals(other.ip))
            return false;
        if (ipToCountry == null) {
            if (other.ipToCountry != null)
                return false;
        } else if (!ipToCountry.equals(other.ipToCountry))
            return false;
        if (message == null) {
            if (other.message != null)
                return false;
        } else if (!message.equals(other.message))
            return false;
        return true;
    }

    public String toString() {
        return "MessageUser [id=" + id + ", ip=" + ip + ", ipToCountry="
                + ipToCountry + ", message=" + message + "]";
    }
    
    public static List<MessageUser> getMessageUserFiltred(String ip,String countryName, String countryCode, Message msg){
        EntityManager em = (EntityManager) Component.getInstance("entityManager");
        Query query ;
        StringBuffer queryString = new StringBuffer() ;
        HashSet < String> prefixes = new HashSet<String>();
        HashSet < String> prefixesUsed = new HashSet<String>();
        HashMap<String ,String > mapOfJoin = new HashMap<String, String>() ;
        HashMap<String , Object > mapOfParameters = new HashMap<String, Object>() ;



        if (countryName != null){
            AndOrWhere.addANDorWHERE(queryString) ;
            prefixes.add("MessageUser mu");
            queryString.append( "mu.ipToCountry.countryName = :countryName" );
            mapOfParameters.put("countryName", countryName);
        }

        if (countryCode != null){
            AndOrWhere.addANDorWHERE(queryString) ;
            prefixes.add("MessageUser mu");
            queryString.append( "mu.ipToCountry.countryCode = :countryCode" );
            mapOfParameters.put("countryCode", countryCode);
        }
        
        if (msg != null){
            AndOrWhere.addANDorWHERE(queryString) ;
            prefixes.add("MessageUser mu");
            queryString.append( "mu.message = :msg" );
            mapOfParameters.put("msg", msg);
        }
        
        if (ip != null){
            double somm = IpToCountry.ipAddress2ipNumber(ip);
            AndOrWhere.addANDorWHERE(queryString);
            prefixes.add("MessageUser mu");
            queryString.append( "mu.ipToCountry.ipFrom<:somm AND mu.ipToCountry.ipTo>:somm" );
            mapOfParameters.put("somm", somm);
        }
        
        if (
                (countryCode == null) &&
                (countryName == null) &&
                (ip == null) &&
                (msg == null) 
        ){
            return null;
        }
            
        
        prefixes.add("MessageUser mu");

        List<String> listOfPrefixes = new ArrayList<String>( prefixes ) ;
        StringBuffer firstPartOfQuery = new StringBuffer() ;

        for ( int i= 0 ; i< listOfPrefixes.size() ; i++  )
        {
            if ( i == 0 ) 
            {
                firstPartOfQuery.append("SELECT distinct mu FROM "    ) ;
            }

            if ( !prefixesUsed.contains(listOfPrefixes.get(i)) )
            {
                if ( prefixesUsed.size() > 0 ) firstPartOfQuery.append(" , "  ) ;

                firstPartOfQuery.append( listOfPrefixes.get(i) ) ;
                if (mapOfJoin.containsKey(listOfPrefixes.get(i)))
                    firstPartOfQuery.append(" " + mapOfJoin.get(listOfPrefixes.get(i)) +" " ) ;
                prefixesUsed.add( listOfPrefixes.get(i) ) ;
            }
        }

        queryString.insert(0, firstPartOfQuery ) ;
        if ( queryString.toString().trim().length() == 0 ) return null ;
        query = em.createQuery(queryString.toString()) ;
        List<String> listOfParameters =  new ArrayList<String>( mapOfParameters.keySet() ) ;
        for ( String param : listOfParameters ){
            query.setParameter( param , mapOfParameters.get(param) ) ;
        }
        log.info("quesryString = " + queryString);
        List<MessageUser> listOfMessageUser = ( List<MessageUser> )query.getResultList(); 
        return listOfMessageUser ;
    }
    
    @SuppressWarnings("unchecked")
    public static List<MessageUser> getListOfAllMessageUser(){
        EntityManager entityManager=(EntityManager)Component.getInstance("entityManager");
        Query queryContact = entityManager.createQuery("SELECT msg From MessageUser msg");
        return (List<MessageUser>)queryContact.getResultList();
    }
    

}