/*******************************************************************************
    * jhunters: Pool League
    * Copyright 2015 Tony Washer
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   ********************************************************************************/
  package net.sourceforge.jhunters.pool.data;
  
  import java.time.LocalDate;
  import java.util.Iterator;
  
  import javafx.beans.property.IntegerProperty;
  import javafx.beans.property.ObjectProperty;
  
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  /**
   * XML document builder.
   */
  public class XmlBuilder {
      /**
       * The current document.
       */
      private final Document theDocument;
  
      /**
       * Constructor.
       * @param pDocument the document
       */
      public XmlBuilder(final Document pDocument) {
          theDocument = pDocument;
      }
  
      /**
       * Build the competition.
       * @param pData the dataSet
       */
      public void buildDataSet(final DataSet pData) {
          /* Create a master element for the item */
          Element myElement = theDocument.createElement(DataSet.OBJECT_NAME);
          theDocument.appendChild(myElement);
  
          /* Build the participant list */
          buildPlayers(myElement, pData.playerIterator());
  
          /* Build the competition list */
          buildCompetitions(myElement, pData.competitionIterator());
      }
  
      /**
       * Build the player list.
       * @param pContainer the containing element
       * @param pPlayers the player iterator
       */
      private void buildPlayers(final Element pContainer,
                                final Iterator<Player> pPlayers) {
          /* Create a master element for the item */
          Element myElement = theDocument.createElement(PlayerList.LIST_NAME);
          pContainer.appendChild(myElement);
  
          /* Iterate through the list */
          while (pPlayers.hasNext()) {
              Player myPlayer = pPlayers.next();
  
              /* build the player */
              buildPlayer(myElement, myPlayer);
          }
      }
  
      /**
       * Build the player.
       * @param pContainer the containing element
       * @param pPlayer the player
       */
      private void buildPlayer(final Element pContainer,
                               final Player pPlayer) {
          /* Create a new element for the player */
          Element myElement = theDocument.createElement(Player.OBJECT_NAME);
          pContainer.appendChild(myElement);
  
          /* Add the properties */
          addIntegerProperty(myElement, pPlayer.idProperty());
          addStringProperty(myElement, pPlayer.nameProperty());
          addStringProperty(myElement, pPlayer.contactProperty());
      }
  
      /**
       * Build the competition list.
      * @param pContainer the containing element
      * @param pCompetitions the competition iterator
      */
     private void buildCompetitions(final Element pContainer,
                                    final Iterator<Competition> pCompetitions) {
         /* Create a master element for the item */
         Element myElement = theDocument.createElement(CompetitionList.OBJECT_NAME);
         pContainer.appendChild(myElement);
 
         /* Iterate through the list */
         while (pCompetitions.hasNext()) {
             Competition myComp = pCompetitions.next();
 
             /* build the player */
             buildCompetition(myElement, myComp);
         }
     }
 
     /**
      * Build the competition.
      * @param pContainer the containing element
      * @param pCompetition the competition
      */
     private void buildCompetition(final Element pContainer,
                                   final Competition pCompetition) {
         /* Create a master element for the item */
         Element myElement = theDocument.createElement(Competition.OBJECT_NAME);
         pContainer.appendChild(myElement);
 
         /* Add the properties */
         addStringProperty(myElement, pCompetition.nameProperty());
         addDateProperty(myElement, pCompetition.startDateProperty());
 
         /* Build the participant list */
         buildParticipants(myElement, pCompetition.participantIterator());
 
         /* Build the fixture list */
         buildFixtures(myElement, pCompetition.fixtureIterator());
     }
 
     /**
      * Build the participant list.
      * @param pContainer the containing element
      * @param pParticipants the participant iterator
      */
     private void buildParticipants(final Element pContainer,
                                    final Iterator<Player> pParticipants) {
         /* Create a master element for the item */
         Element myElement = theDocument.createElement(Competition.PARTICIPANT_LIST);
         pContainer.appendChild(myElement);
 
         /* Iterate through the list */
         while (pParticipants.hasNext()) {
             Player myPlayer = pParticipants.next();
 
             /* build the participant */
             buildParticipant(myElement, myPlayer);
         }
     }
 
     /**
      * Build the participant.
      * @param pContainer the containing element
      * @param pPlayer the player
      */
     private void buildParticipant(final Element pContainer,
                                   final Player pPlayer) {
         /* Create a new element for the player */
         Element myElement = theDocument.createElement(Competition.PARTICIPANT_NAME);
         pContainer.appendChild(myElement);
 
         /* Add the properties */
         addStringProperty(myElement, pPlayer.nameProperty());
     }
 
     /**
      * Build the fixtures.
      * @param pContainer the containing element
      * @param pFixtureSets the fixtureSet
      */
     private void buildFixtures(final Element pContainer,
                                final Iterator<FixtureSet> pFixtureSets) {
         /* Create a master element for the list */
         Element myList = theDocument.createElement(FixtureList.OBJECT_NAME);
         pContainer.appendChild(myList);
 
         /* Iterate through the fixtureSets */
         while (pFixtureSets.hasNext()) {
             FixtureSet mySet = pFixtureSets.next();
 
             /* build the fixture set */
             buildFixtureSet(myList, mySet);
         }
     }
 
     /**
      * Build the fixtureSet.
      * @param pContainer the containing element
      * @param pSet the fixtureSet
      */
     private void buildFixtureSet(final Element pContainer,
                                  final FixtureSet pSet) {
         /* Create a master element for the set */
         Element mySet = theDocument.createElement(FixtureSet.OBJECT_NAME);
         pContainer.appendChild(mySet);
 
         /* Add the week number */
         addIntegerProperty(mySet, pSet.weekNoProperty());
 
         /* Iterate through the fixtures */
         Iterator<Fixture> myIterator = pSet.fixtureIterator();
         while (myIterator.hasNext()) {
             Fixture myFixture = myIterator.next();
 
             /* build the fixture */
             buildFixture(mySet, myFixture);
         }
     }
 
     /**
      * Build the fixture.
      * @param pContainer the containing element
      * @param pFixture the fixture
      */
     private void buildFixture(final Element pContainer,
                               final Fixture pFixture) {
         /* Create a new element for the fixture */
         Element myElement = theDocument.createElement(Fixture.OBJECT_NAME);
         pContainer.appendChild(myElement);
 
         /* Add the properties */
         addDateProperty(myElement, pFixture.dateProperty());
         addDateProperty(myElement, pFixture.newDateProperty());
         addPlayerProperty(myElement, pFixture.homePlayerProperty());
         addPlayerProperty(myElement, pFixture.awayPlayerProperty());
         addResultProperty(myElement, pFixture.resultProperty());
     }
 
     /**
      * Add a string property to the element.
      * @param pElement the element to hold the property.
      * @param pProperty the property to add
      */
     private void addStringProperty(final Element pElement,
                                    final ObjectProperty<String> pProperty) {
         /* Access the value */
         String myValue = pProperty.getValue();
         if (myValue != null) {
             /* Create a new element for the string */
             Element myElement = theDocument.createElement(pProperty.getName());
             myElement.setTextContent(myValue);
             pElement.appendChild(myElement);
         }
     }
 
     /**
      * Add an integer property to the element.
      * @param pElement the element to hold the property.
      * @param pProperty the property to add
      */
     private void addIntegerProperty(final Element pElement,
                                     final IntegerProperty pProperty) {
         /* Access the value */
         Integer myValue = pProperty.getValue();
         if (myValue != null) {
             /* Create a new element for the string */
             Element myElement = theDocument.createElement(pProperty.getName());
             myElement.setTextContent(myValue.toString());
             pElement.appendChild(myElement);
         }
     }
 
     /**
      * Add a player property to the element.
      * @param pElement the element to hold the property.
      * @param pProperty the property to add
      */
     private void addPlayerProperty(final Element pElement,
                                    final ObjectProperty<Player> pProperty) {
         /* Access the value */
         Player myValue = pProperty.getValue();
         if (myValue != null) {
             /* Create a new element for the player */
             Element myElement = theDocument.createElement(pProperty.getName());
             myElement.setTextContent(myValue.getName());
             pElement.appendChild(myElement);
         }
     }
 
     /**
      * Add a result property to the element.
      * @param pElement the element to hold the property.
      * @param pProperty the property to add
      */
     private void addResultProperty(final Element pElement,
                                    final ObjectProperty<Result> pProperty) {
         /* Access the value */
         Result myValue = pProperty.getValue();
         if (myValue != null) {
             /* Create a new element for the result */
             Element myElement = theDocument.createElement(pProperty.getName());
             myElement.setTextContent(myValue.toString());
             pElement.appendChild(myElement);
         }
     }
 
     /**
      * Add a date property to the element.
      * @param pElement the element to hold the property.
      * @param pProperty the property to add
      */
     private void addDateProperty(final Element pElement,
                                  final ObjectProperty<LocalDate> pProperty) {
         /* Access the value */
         LocalDate myValue = pProperty.getValue();
         if (myValue != null) {
             /* Create a new element for the result */
             Element myElement = theDocument.createElement(pProperty.getName());
             myElement.setTextContent(DataParser.formatDate(myValue));
             pElement.appendChild(myElement);
         }
     }
 }