/*
    * Copyright 2010 the original author or authors.
    *
    * 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 org.callbackparams.combine;
  
  import java.util.IdentityHashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Random;
  
  /**
   * @author Henrik Kaipe
   */
  class Default2CombinationPicker implements AllPossible2Combinations.Picker {
  
      private final int index;
      private final ValueWrapper[] wrappedValues;
      private int greatestCombinationCount = 1;
      private int nbrOf2CombinationsToSatisfy = 0;
      private final Random random;
      
      private int totalCount;
  
      class CombinationCounter {
          private int count = 0;
  
          public CombinationCounter() {
              ++nbrOf2CombinationsToSatisfy;
          }
  
          int getCount() {return count; }
  
          void increaseCount() {
              if (1 == ++count) {
                  if (--nbrOf2CombinationsToSatisfy < 0) {
                      throw new AssertionError("Negativ number of 2-combinations"
                              + " at total count = " + totalCount);
                  }
              } else if (greatestCombinationCount < count) {
                  greatestCombinationCount = count;
              }
          }
          
          /** Useful for debugging */
          public String toString() {return "" + count;}
      }
      
      private transient Object[] record;
      private transient int currentRecordIndex;
      private transient int currentCount;
      private transient final ValueWrapper[] options, selections;
      private transient int nbrOfOptions, nbrOfSelections;
      private transient boolean needyFirst;
      
      private transient boolean selectedCountCorrect;
      private transient int selectedTotalNeeds;
      
      class ValueWrapper {
          
          private final Object value;
          private final Map[] combinationCounters = new Map[index];
          
          private int valueCount = 0;
  
          ValueWrapper(final Object value, final Object[][] allValues) {
              this.value = value;
              
              for (int mapIx = 0 ; mapIx < index ; ++mapIx) {
                  combinationCounters[mapIx] = new IdentityHashMap();
                  
                  final Object[] combinationsOtherValues = allValues[mapIx];
                  for (int otherValuesIx = 0
                          ; otherValuesIx < combinationsOtherValues.length
                          ; ++otherValuesIx) {
                      combinationCounters[mapIx].put(
                              combinationsOtherValues[otherValuesIx],
                              new CombinationCounter());
                  }
              }
          }
          
          private void select(boolean isCountCorrect, int totalNeeds) {
              selectedCountCorrect = isCountCorrect;
              selectedTotalNeeds = totalNeeds;
              selections[0] = this;
              nbrOfSelections = 1;
         }
         
         private CombinationCounter combinationCount() {
             return (CombinationCounter) combinationCounters[currentRecordIndex]
                     .get(record[currentRecordIndex]);
         }
         
         private int totalNeeds() {
             int needCount = 0;
             for (Iterator iter =
                     combinationCounters[currentRecordIndex].values().iterator()
                     ; iter.hasNext() ;) {
                 final CombinationCounter cc = (CombinationCounter) iter.next();
                 
                 if (currentCount == cc.getCount()) {
                     ++needCount;
                 }
             }
             return needCount;
         }
         
         void consider() {
             final boolean isThisCountCorrect =
                     currentCount == combinationCount().getCount();
             if (0 == nbrOfSelections) {
                 select(isThisCountCorrect, totalNeeds());
                 return;
             }
             
             if (selectedCountCorrect && false == isThisCountCorrect) {
                 /* This option is dropped */
                 return;
             }
             
             final int thisTotalNeeds = totalNeeds();
             
             if (isThisCountCorrect == selectedCountCorrect
                     && thisTotalNeeds == selectedTotalNeeds) {
                 selections[nbrOfSelections] = this;
                 ++nbrOfSelections;
                 return;
                 
             } else if (false == isThisCountCorrect) {
                 if (thisTotalNeeds < selectedTotalNeeds) {
                     select(isThisCountCorrect, thisTotalNeeds);
                 } else {
                     /* This option is dropped */
                 }
                 return;
                 
             } else if (false == selectedCountCorrect
                     || needyFirst && selectedTotalNeeds < thisTotalNeeds
                     || !needyFirst && thisTotalNeeds < selectedTotalNeeds) {
                 select(isThisCountCorrect, thisTotalNeeds);
                 return;
                 
             } else {
                 /* This option is dropped */
                 return;
             }
         }
         
         int getCount() {
             return valueCount;
         }
         
         void pickValue() {
             record[index] = value;
             for (currentRecordIndex = 0
                     ; currentRecordIndex < index ; ++currentRecordIndex) {
                 combinationCount().increaseCount();
             }
             record = null;//To raise NullPointer if same record is used twice
             ++totalCount;
             ++valueCount;
         }
     }
 
     Default2CombinationPicker(
             final int index, final Object[][] values, final Random random) {
         this.index = index;
         this.wrappedValues = new ValueWrapper[values[index].length];
         this.random = random;
         
         for (int i = 0 ; i < this.wrappedValues.length ; ++i) {
             wrappedValues[i] = new ValueWrapper(values[index][i], values);
         }
         this.options = new ValueWrapper[wrappedValues.length];
         this.selections = new ValueWrapper[wrappedValues.length];
     }
 
     private void setupOptions() {
         final int countForOptions = totalCount / wrappedValues.length;
         nbrOfOptions = 0;
         for (int i = 0 ; i < wrappedValues.length ; ++i) {
             final ValueWrapper vw = wrappedValues[i];
             
             if (countForOptions == vw.getCount()) {
                 options[nbrOfOptions] = vw;
                 ++nbrOfOptions;
             }
         }
 
         /*
          * The rules by which needyFirst is determined are questionable.
          * The value set below has proven to be better than both of the
          * constant values "true" and "false" when using the random-seed
          * 1216208375531 and running the test
          * TestAllPossible2CombinatinsWith3ValuesArraysLongerThan1.test444()
          * (As least if we look to how things were on 2008-07-16).
          */
         needyFirst = 2 * nbrOfOptions <= wrappedValues.length;
         
         nbrOfSelections = 0;
     }
 
     public void pick(final Object[] record) {
         this.record = record;
         
         if (totalCount < wrappedValues.length) {
             wrappedValues[totalCount].pickValue();
             return;
         }
         
         setupOptions();
         if (1 == nbrOfOptions) {
             options[0].pickValue();
             return;
         }
         
         assert 2 <= nbrOfOptions;
         for (currentCount = all2CombinationsAreSatisfied() ? 1 : 0
                 ; currentCount < greatestCombinationCount ; ++currentCount)
         for (currentRecordIndex = 0
                 ; currentRecordIndex < index ; ++currentRecordIndex)
         {
             for (int i = 0 ; i < nbrOfOptions ; ++i) {
                 options[i].consider();
             }
             
             if (1 == nbrOfSelections) {
                 selections[0].pickValue();
                 return;
                 
             } else {
                 assert 2 <= nbrOfSelections;
                 System.arraycopy(selections, 0, options, 0, nbrOfSelections);
                 nbrOfOptions = nbrOfSelections;
                 nbrOfSelections = 0;
             }
         }
         
         /* Last resort - pick randomly among the remaining options */
         options[random.nextInt(nbrOfOptions)].pickValue();
     }
 
     public boolean all2CombinationsAreSatisfied() {
         return 0 == nbrOf2CombinationsToSatisfy;
     }
 }