/*
    * Sonar, entreprise quality control tool.
    * Copyright (C) 2007-2008 Hortis-GRC SA
    * mailto:be_agile HAT hortis DOT ch
    *
    * Sonar is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 3 of the License, or (at your option) any later version.
   *
   * Sonar is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with Sonar; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
   */
  package org.sonar.commons.rules;
  
  import ch.hortis.sonar.model.*;
  import org.sonar.commons.database.DatabaseManager;
  
  import javax.persistence.NoResultException;
  import javax.persistence.Query;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  public class RulesDao {
    private DatabaseManager databaseManager;
    private List<RulesCategory> rulesCategories;
  
    public RulesDao(DatabaseManager manager) {
      this.databaseManager = manager;
    }
  
    public Rule getRule(String pluginKey, String ruleKey) {
      try {
        return (Rule) databaseManager.createQuery("SELECT r FROM Rule r WHERE r.pluginName=:pluginKey AND r.key=:ruleKey")
            .setParameter("pluginKey", pluginKey)
            .setParameter("ruleKey", ruleKey)
            .getSingleResult();
      } catch (NoResultException e) {
        return null;
      }
    }
  
    public List<Rule> getRules() {
      return databaseManager.createQuery("SELECT r FROM Rule r").getResultList();
    }
  
  
    public List<Rule> getRulesByPlugin(String pluginKey) {
      return databaseManager.createQuery("SELECT r FROM Rule r WHERE r.pluginName=:pluginKey").setParameter("pluginKey", pluginKey).getResultList();
    }
  
    public List<Rule> getRulesByCategory(RulesCategory categ) {
      List<Rule> result = new ArrayList<Rule>();
      for (Rule rule : getRules()) {
        if (rule.getRulesCategory().equals(categ)) {
          result.add(rule);
        }
      }
      return result;
    }
  
    public Rule getRuleByKey(String pluginKey, String ruleKey) {
      try {
        return (Rule) databaseManager.createQuery(
            "SELECT r FROM Rule r WHERE r.key=:ruleKey AND r.pluginName=:pluginKey").
            setParameter("ruleKey", ruleKey).
            setParameter("pluginKey", pluginKey).
            getSingleResult();
      } catch (NoResultException ex) {
        return null;
      }
    }
  
    public Long getRulesCount(List<String> plugins, String categoryName) {
      return (Long) databaseManager.createQuery(
          "SELECT COUNT(r) FROM Rule r WHERE r.pluginName IN (:pluginNames) AND r.rulesCategory=:rulesCategory").
          setParameter("pluginNames", plugins).
          setParameter("rulesCategory", getCategory(categoryName)).
          getSingleResult();
    }
  
  
    public List<RulesCategory> getCategories() {
      if (rulesCategories == null) {
        Query query = databaseManager.createQuery("SELECT r FROM RulesCategory r");
        rulesCategories = query.getResultList();
      }
      return rulesCategories;
    }
  
    public RulesCategory getCategory(String key) {
      try {
       return (RulesCategory) databaseManager
           .createQuery("select rc from RulesCategory rc where rc.name=:key")
           .setParameter("key", key)
           .getSingleResult();
     } catch (NoResultException ex) {
       return null;
     }
   }
 
 
   public List<RuleParam> getRuleParams() {
     return (List<RuleParam>) databaseManager.createQuery("FROM RuleParam").getResultList();
   }
 
 
   public List<RulesProfile> getActiveProfiles() {
     return databaseManager.createQuery("select rp from RulesProfile rp where rp.active=true").getResultList();
   }
 
   public RulesProfile getActiveProfile(String languageKey) {
     try {
       return (RulesProfile) databaseManager
           .createQuery("select rp from RulesProfile rp where rp.active=true and rp.language=:languageKey")
           .setParameter("languageKey", languageKey)
           .getSingleResult();
     } catch (NoResultException e) {
       return null;
     }
   }
 
   public List<RulesProfile> getProfiles(String languageKey) {
     return (List<RulesProfile>) databaseManager.createQuery(
         "SELECT rp FROM RulesProfile rp WHERE language=:languageKey")
         .setParameter("languageKey", languageKey)
         .getResultList();
   }
 
   public List<RulesProfile> getProvidedProfiles() {
     return (List<RulesProfile>) databaseManager.createQuery(
         "SELECT rp FROM RulesProfile rp WHERE rp.provided=true")
         .getResultList();
   }
 
   public RulesProfile getProfile(String languageKey, String profileName) {
     try {
       return (RulesProfile) databaseManager.createQuery(
           "SELECT rp FROM RulesProfile rp WHERE rp.language=:languageKey AND rp.name=:profileName")
           .setParameter("languageKey", languageKey)
           .setParameter("profileName", profileName)
           .getSingleResult();
     } catch (NoResultException e) {
       return null;
     }
   }
 
   public void addActiveRulesToProfile(List<ActiveRule> activeRules, int profileId, String pluginKey) {
     RulesProfile rulesProfile = getProfileById(profileId);
     for (ActiveRule activeRule : activeRules) {
       synchronizeRuleOfActiveRule(activeRule, pluginKey);
       activeRule.setRulesProfile(rulesProfile);
       databaseManager.save(activeRule);
     }
   }
 
 //  public List<ActiveRule> getActiveRules(int profileId, String pluginKey) {
 //    return (List<ActiveRule>) databaseManager.createQuery(
 //        "SELECT ar FROM ActiveRule ar WHERE ar.rule.pluginName=:name AND ar.rulesProfile.id=:id").
 //        setParameter("id", profileId).
 //        setParameter("name", pluginKey).
 //        getResultList();
 //  }
 
 
   public List<RuleFailure> getRuleFailures(Snapshot snapshot) {
     return databaseManager.createQuery(
         "SELECT rf FROM RuleFailure rf " +
             "WHERE rf.snapshotId=:snapshotId")
         .setParameter("snapshotId", snapshot.getId())
         .getResultList();
   }
 
 
   public void synchronizeRuleOfActiveRule(ActiveRule activeRule, String pluginKey) {
     Rule rule = activeRule.getRule();
     Rule ruleFromDataBase = getRuleByKey(pluginKey, rule.getKey());
     activeRule.setRule(ruleFromDataBase);
     List<RuleParam> ruleParamsFromDataBase = getRuleParams();
     for (ActiveRuleParam activeRuleParam : activeRule.getActiveRuleParams()) {
       boolean found = false;
       Iterator<RuleParam> iterator = ruleParamsFromDataBase.iterator();
       while (iterator.hasNext() && !found) {
         RuleParam ruleParamFromDataBase = iterator.next();
         if (isRuleParamEqual(activeRuleParam.getRuleParam(), ruleParamFromDataBase, rule.getKey(), pluginKey)) {
           activeRuleParam.setRuleParam(ruleParamFromDataBase);
           found = true;
         }
       }
     }
   }
 
   public boolean isRuleParamEqual(RuleParam ruleParam, RuleParam ruleParamFromDatabase, String ruleKey, String pluginKey) {
     return ruleParam.getKey().equals(ruleParamFromDatabase.getKey()) &&
         ruleKey.equals(ruleParamFromDatabase.getRule().getKey()) &&
         ruleParamFromDatabase.getRule().getPluginName().equals(pluginKey);
   }
 
   public RulesProfile getProfileById(int profileId) {
     return databaseManager.getEntityManager().getReference(RulesProfile.class, profileId);
   }
 
 }