package org.archive.accesscontrol.model;

import java.util.Collection;
import java.util.List;

import org.archive.accesscontrol.RuleDao;
import org.archive.surt.NewSurtTokenizer;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
 * The rule data access object provides convenience methods for using Hibernate
 * to access stored rules.  The database connection is expected to be configured 
 * using the SpringFramework ORM layer.
 * 
 * @author aosborne
 */
@SuppressWarnings("unchecked")
public class HibernateRuleDao extends HibernateDaoSupport implements RuleDao {
    public Rule getRule(Long id) {
        return (Rule) getHibernateTemplate().get(Rule.class, id);
    }

    public List<Rule> getAllRules() {
        return getHibernateTemplate().find("from Rule");
    }

    public List<Rule> getRulesWithSurtPrefix(String prefix) {
        // escape wildcard characters % and _ using ! as the escape character.
        prefix = prefix.replace("!", "!!").replace("%", "!%")
                .replace("_", "!_");
        return getHibernateTemplate().find(
                "from Rule rule where rule.surt like ? escape '!'",
                prefix + "%");
    }

    public List<Rule> getRulesWithExactSurt(String surt) {
        return getHibernateTemplate().find(
                "from Rule rule where rule.surt = ?", surt);
    }
    
    /**
     * Returns the "rule tree" for a given SURT. This is a sorted set of all
     * rules equal or lower in specificity than the given SURT plus all rules on
     * the path from this SURT to the root SURT "(".
     * 
     * The intention is to call this function with a domain or public suffix,
     * then queries within that domain can be made very fast by searching the
     * resulting list.
     * 
     * @param surt
     * @return
     */
    public RuleSet getRuleTree(String surt) {
        RuleSet rules = new RuleSet();
        
        // add the root SURT
        rules.addAll(getRulesWithExactSurt("("));
        
        boolean first = true;
        for (String search: new NewSurtTokenizer(surt).getSearchList()) {
            if (first) {
                first = false;
                rules.addAll(getRulesWithSurtPrefix(search));
            } else {
                rules.addAll(getRulesWithExactSurt(search));
            }
        }
        
        return rules;
    }

    public void saveRule(Rule rule) {
        getHibernateTemplate().saveOrUpdate(rule);
    }
    
    public boolean saveRuleIfNotDup(Rule rule)
    {
    	List<Rule> allRules = getAllRules();
    	
    	for (Rule existingRule : allRules)
    	{
    		if (existingRule.compareTo(rule) == 0) {
    			// If we're not the same, rule then we're a dup!
    			if ((rule.getId() == null) || !rule.getId().equals(existingRule.getId())) {
    				return false;	
    			}
    		}
    	}
    	
    	saveRule(rule);
    	return true;
    } 
    
    /**
     * Save a rule and a change log entry in one go. (Uses a transaction).
     * @param rule
     * @param change
     */
    public void saveRule(Rule rule, RuleChange change) {
        Session session1 = getHibernateTemplate().getSessionFactory().openSession();
        Transaction tx = session1.beginTransaction();
        session1.saveOrUpdate(rule);
        session1.save(change);
        tx.commit();
        session1.close();
    }
    
    public void saveChange(RuleChange change) {
        getHibernateTemplate().saveOrUpdate(change);
    }
    
    public void deleteRule(Long id) {
        Object record = getHibernateTemplate().load(Rule.class, id);
        getHibernateTemplate().delete(record);
    }
    
    public void deleteAllRules() {
        getHibernateTemplate().bulkUpdate("delete from Rule");
    }

    public void prepare(Collection<String> surts) {
        // no-op
    }
}