//  Open Hold em is a java-based, server and client environment for hosting 
   //  your own texas hold poker tournaments, and regular tables. It is full 
   //  customizable and deployable in a number of different java-based hosting 
   //  environments.
   //  Copyright (C) 2005 Chris A. Mattmann <chris@baron.pagemewhen.com>
   //
   //  This program is free software; you can redistribute it and/or modify
   //  it under the terms of the GNU General Public License as published by
   //  the Free Software Foundation; either version 2 of the License, or
  //  (at your option) any later version.
  //
  //  This program 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 General Public License for more details.
  //
  //  You should have received a copy of the GNU General Public License
  //  along with this program; if not, write to the Free Software
  //  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  //
  //  $Id: RuleSetReader.java,v 1.2 2005/08/07 02:48:36 mattmann Exp $
  
  package com.openholdem.util;
  
  import com.openholdem.structs.RuleSet;
  import com.openholdem.structs.exceptions.PokerException;
  
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NodeList;
  
  import org.xml.sax.InputSource;
  
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.DocumentBuilder;
  
  import java.net.URL;
  
  import java.io.IOException;
  
  /***
   * @author mattmann
   * @version $Revision: 1.2 $
   * 
   * <p>
   * A Rule Set reader reads an XML file and creates a {@link RuleSet} object.
   * </p>
   * 
   */
  public class RuleSetReader {
  
      /* the rule set xml file that contains the poker game rule set */
      private URL ruleSetUrl = null;
  
      /***
       * <p>
       * Constructs a new RuleSetReader that will read the given url file
       * </p>
       * 
       * @param ruleUrl
       */
      public RuleSetReader(URL ruleUrl) {
          ruleSetUrl = ruleUrl;
      }
  
      public RuleSet readRuleSet() throws PokerException, Exception {
          RuleSet r = new RuleSet();
  
          DocumentBuilderFactory factory = null;
          DocumentBuilder parser = null;
          Document document = null;
          InputSource inputSource = null;
  
          try {
              inputSource = new InputSource(ruleSetUrl.openStream());
          } catch (IOException e) {
              e.printStackTrace();
              throw new PokerException("Unable to read rule set from url "
                      + ruleSetUrl);
          }
  
          try {
              factory = DocumentBuilderFactory.newInstance();
              parser = factory.newDocumentBuilder();
              document = parser.parse(inputSource);
          } catch (Exception parseException) {
              parseException.printStackTrace();
              return null;
          }
  
          Element ruleSet = document.getDocumentElement();
  
          Element handTag = DOMUtil.getFirstElement(ruleSet, "hand");
  
          if (handTag == null) {
              throw new PokerException("poker rules file " + ruleSetUrl
                      + " must define a hand element!");
          }
  
         // pick up the attributes
         // numPlayerCards="2" minHandCardsUsed="0" maxHandCardsUsed="2"
         // community="2"
 
         String numPlayerCards = handTag.getAttribute("numPlayerCards");
 
         if (numPlayerCards == null) {
             throw new PokerException("poker rules file " + ruleSetUrl
                     + " must define the hand attribute numPlayerCards!");
         } else {
             // try and parse it as an int
             try {
                 r.setFNumPlayerCards(Integer.parseInt(numPlayerCards));
             } catch (NumberFormatException e) {
                 e.printStackTrace();
                 throw new PokerException(
                         "can't parse num player cards attribute "
                                 + numPlayerCards + " ! " + e.getMessage());
             }
         }
 
         String minHandCardsUsed = handTag.getAttribute("minHandCardsUsed");
 
         if (minHandCardsUsed == null) {
             throw new PokerException("poker rules file " + ruleSetUrl
                     + " must define the hand attribute minHandCardsUsed!");
         } else {
             // try and parse it as an int
             try {
                 r.setFMinHandCardsUsed(Integer.parseInt(minHandCardsUsed));
             } catch (NumberFormatException e) {
                 e.printStackTrace();
                 throw new PokerException(
                         "can't parse min hand cards used attribute "
                                 + minHandCardsUsed + " ! " + e.getMessage());
             }
         }
 
         String maxHandCardsUsed = handTag.getAttribute("maxHandCardsUsed");
 
         if (maxHandCardsUsed == null) {
             throw new PokerException("poker rules file " + ruleSetUrl
                     + " must define the hand attribute maxHandCardsUsed!");
         } else {
             // try and parse it as an int
             try {
                 r.setFMaxHandCardsUsed(Integer.parseInt(maxHandCardsUsed));
             } catch (NumberFormatException e) {
                 e.printStackTrace();
                 throw new PokerException(
                         "can't parse max hand cards used attribute "
                                 + maxHandCardsUsed + " ! " + e.getMessage());
             }
         }
 
         String community = handTag.getAttribute("community");
 
         if (community == null) {
             throw new PokerException("poker rules file " + ruleSetUrl
                     + " must define the hand attribute community!");
         } else {
             // try and parse it as an int
             try {
                 r.setFNumCommunityCards(Integer.parseInt(community));
             } catch (NumberFormatException e) {
                 e.printStackTrace();
                 throw new PokerException(
                         "can't parse community cards attribute " + community
                                 + " ! " + e.getMessage());
             }
         }
 
         // now iterate through the set of handRanks
         Element handRanks = DOMUtil.getFirstElement(ruleSet, "handRanks");
 
         NodeList handRanksRoot = handRanks.getElementsByTagName("rank");
 
         // should be at least two hand ranks
         if (handRanksRoot.getLength() < 2) {
             throw new PokerException(
                     "Must be at least two hand ranks in poker rule set file "
                             + ruleSetUrl);
         }
 
         // now get the
 
         for (int i = 0; i < handRanksRoot.getLength(); i++) {
             Element rankNode = (Element) handRanksRoot.item(i);
 
             // two attributes num (rank) and hand (name)
             String rankStr = rankNode.getAttribute("num");
 
             if (rankStr == null) {
                 throw new PokerException("rank node from poker file "
                         + ruleSetUrl + " must define the attribute num!");
             }
 
             // get the name now
 
             String handName = rankNode.getAttribute("hand");
 
             if (handName == null) {
                 throw new PokerException("rank node from poker file "
                         + ruleSetUrl + " must define the attribute hand!");
             }
 
             // try and parse the hand name as an int
             try {
                 r.getFHandRanks().add(
                         new RuleSet().new HandRank(Integer.parseInt(rankStr),
                                 handName));
             } catch (NumberFormatException e) {
                 e.printStackTrace();
                 throw new PokerException(
                         "Unable to parse the rank of the hand name " + handName
                                 + " in poker file " + ruleSetUrl + " !");
             }
         }
 
         return r;
 
     }
 
 }