/*
 *  $Source: /open/projects/WebARTS/ca/bc/webarts/widgets/LotterySimulator.java $
 *  $Name:  $
 *
 *  $Date: 2018-03-02 22:29:54 -0800 (Fri, 02 Mar 2018) $
 *  $Locker:  $
 *
 *
 *  Written by Tom Gutwin - WebARTS Design.
 *  Copyright (C) 2010 WebARTS Design, North Vancouver Canada
 *  http://www.webarts.bc.ca
 *
 *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

 package ca.bc.webarts.widgets;

import ca.bc.webarts.tools.Log;
import ca.bc.webarts.tools.StreamGobbler;

import gnu.regexp.RE;
import gnu.regexp.REException;

import java.io.File;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

/**
 *  Simulates the drawing of a 6/49 style lottery to analyze different number selection scenarios in
*  an attempt to see what are the best sequences of numbers.
 *
 * @author    TGutwin
 */
public class LotterySimulator
{
  /**  A holder for this clients System File Separator.  */
  public final static String SYSTEM_FILE_SEPERATOR = File.separator;

  /**  A holder for this clients System line termination separator.  */
  public final static String SYSTEM_LINE_SEPERATOR =
                                           System.getProperty("line.separator");

  /**
   *  A constant to specify which dialog to open with the chooseFileDialog.
   */
  public final static short OPEN_DIALOG = 0;

  /**
   *  A constant to specify which dialog to open with the chooseFileDialog.
   */
  public final static short SAVE_DIALOG = 1;

  /**  The VM classpath (used in some methods)..  */
  public static String CLASSPATH = System.getProperty("class.path");

  /**  The users home ditrectory.  */
  public static String USERHOME = System.getProperty("user.home");

  /**  The users pwd ditrectory.  */
  public static String USERDIR = System.getProperty("user.dir");

  /**  A holder This classes name (used when logging).  */
  private static String CLASSNAME = "ca.bc.webarts.widgets.LotterySimulator";

  /**  Gets a Log instance in case any calling classes are using it.  */
  private static Log log_ = Log.getInstance();

  private static boolean verbose = false;
  private static boolean verbose2 = false;

  /**  Class flag signifying if the initUtil method has been called  */
  private static boolean initClass = false;

  /** If a big win, then stop spending more money **/
  private boolean stopOnBigWin = true;
  private float quiteEarlyRatio = 1.4f;

  private int ones, twos, twosPlus, threes, fours, fives, fivesPlus, sixes;
  private long onesPay, twosPay, twosPlusPay, threesPay, foursPay, fivesPay, fivesPlusPay, sixesPay;
  private float onesChance, twosChance, twosPlusChance, threesChance, foursChance, fivesChance, fivesPlusChance, sixesChance;
  public long payout = 0;
  private int numbers = 49;
  private int initialPool = 30000000;
  private int pool = initialPool;
  private float poolIncrementPercent = 0.47f;
  private int numTicketsSold = pool;
  private int ticketPrice = 2;

  /**
   *  Constructor for the LotterySimulator object
   * @param numDraws is the number of Draws to run
   * @param tixPerDraw is the number of tix purchased per Draw
   */
  public LotterySimulator(int numDraws, int tixPerDraw)
  {
    final String methodName = CLASSNAME + ": LotterySimulator(int)";
    initClass();
    if (log_ != null)
    {
      log_.setLogLevel(Log.MAJOR);
      log_.startMethod(methodName);
    }

    Vector<Long>[]  picks = new Vector[tixPerDraw];
    int carries = 0;
    int numSold = 0;
    int invest = 0;
    float benefitCost = 0.0f;
    long currDrawPayout = 0;
    int drawNum = 0;

    for (drawNum = 0; drawNum < numDraws&& benefitCost < quiteEarlyRatio; drawNum++)
    {
      //Vector<Long>  myPicks = rollDice(6,numbers);
      for (int pickNum = 0; pickNum < tixPerDraw; pickNum++)
      {
        picks[pickNum] = rollDice(6,numbers);

        if (verbose) System.out.print("\nPick "+pickNum+": ");
        for (int i = 0; i < picks[pickNum].size(); i++)
        {
          if (verbose) System.out.print(""+picks[pickNum].get(i)+(i<(picks[pickNum].size()-1)?", ":""));
        }
      }

      Vector<Long>  draw = rollDice(6,49);
      long bonus = drawBonusNumber(draw, numbers);
      if (verbose) System.out.print("\n ** Draw ");
      for (int i = 0; i < draw.size(); i++)
      {
        if (verbose) System.out.print(""+draw.get(i)+(i<(draw.size()-1)?", ":""));
      }
      if (verbose) System.out.println(" bonus "+ bonus);

      Vector<Long> myPick = null;
      ones = 0;
      twos = 0;
      twosPlus = 0;
      threes = 0;
      fours = 0;
      fives = 0;
      fivesPlus = 0;
      sixes = 0;

      for (int pickNum = 0; pickNum < tixPerDraw; pickNum++)
      {
        myPick = picks[pickNum];
        switch (matches(draw, myPick))
        {
          case 1:
            ones++;
            break;

          case 2:
            if (myPick.contains(bonus))
              twosPlus++;
            else
              twos++;
            break;

          case 3:
            threes++;
            break;

          case 4:
            fours++;
            break;

          case 5:
            if (myPick.contains(bonus))
              fivesPlus++;
            else
              fives++;
            break;

          case 6:
            sixes++;
            break;

          default:
        }

        if (verbose) System.out.println(" matches " + matches(draw, myPick));
      }

      // Draw complete,  so calc Payouts
      calculatePayouts(pool);
      currDrawPayout = ones*onesPay+twos*twosPay+twosPlus*twosPlusPay+
                       threes*threesPay+fours*foursPay+fives*fivesPay+fivesPlus*fivesPlusPay+
                       sixes*sixesPay;
      payout+=currDrawPayout;
      if (!someoneWonTheJackpot() && matches(draw, myPick)<6)
      {
        carries++;
        pool+=(int)(poolIncrementPercent*(float)getNumTicketsSold(pool)*(float)ticketPrice);
        if (verbose) System.out.print(""+carries);
        if (verbose2) System.out.println("carried "+pool);
      }
      else
      {
        pool=initialPool;
        carries=0;
      }

      invest = ticketPrice*(drawNum+1)*tixPerDraw ;
      benefitCost = (float)payout/(float)invest;
      //if (verbose|| verbose2)
        System.out.println("Current Draw:"+drawNum+"("+pool+")  currPayout=$"+currDrawPayout +"  TotInvested=$"+invest +"   TotalWON=$"+payout+"   runningBenefitCost="+benefitCost);
      // Go back and draw again
    }
    if (verbose|| verbose2) System.out.println("");

    // Calc my results
    numSold = Math.round(getNumTicketsSold(pool));
    invest = ticketPrice*drawNum*tixPerDraw ;
    benefitCost = (float)payout/(float)invest;
    if (drawNum<numDraws) System.out.println("****WON BIG - Stopped Early.");
    System.out.println("With "+drawNum+" draws and "+tixPerDraw +" tickets per Draw. ");
    if (verbose)
    {
      System.out.println("    ones:      "+ones+ " ($"+ones*onesPay+")");
      System.out.println("    twos:      "+twos+ " ($"+twos*twosPay+")");
      System.out.println("    twosPlus:  "+twosPlus+ " ($"+twosPlus*twosPlusPay+")");
      System.out.println("    threes:    "+threes+ " ($"+threes*threesPay+
                        // " from a share of $"+ (numSold* threesChance*threesPay)+
                         ")");
      System.out.println("    fours:     "+fours+ " ($"+fours*foursPay+
                        // " from a share of $"+(numSold* foursChance*foursPay)+
                         ")");
      System.out.println("    fives:     "+fives+ " ($"+fives*fivesPay+
                        // " from a share of $"+ (numSold* fivesChance*fivesPay)+
                         ")");
      System.out.println("    fivesPlus: "+fivesPlus+ " ($"+fivesPlus*fivesPlusPay+
                        // " from a share of $"+ (numSold* fivesPlusChance*fivesPlusPay)+
                         ")");
      System.out.println("    sixes:     "+sixes+ " ($"+sixes*sixesPay+
                        // " from a share of $"+ (numSold* sixesChance*sixesPay)+
                         ")");
    }
    System.out.println("Cost: $"+invest +"  PAYOUT: $"+payout +"  net="+(payout-(ticketPrice*drawNum*tixPerDraw))+
                       "   Benfit Cost Ratio="+benefitCost );
  }


  public static String printUsage()
  {
    final String methodName = CLASSNAME + ": printUsage()";
    String retVal = "";

    retVal += "Class ca.bc.webarts.widgets.LotterySimulator\n";
    retVal += "\n";
    retVal += "Usage: java ca.bc.webarts.widgets.LotterySimulator [-v[v][t tixPerDraw]] numDraws\n";
    retVal += "      one command parameter is required... numDraws - the number of draws to make\n";
    retVal += "Examples:\n";
    retVal += "      LotterySimulator -h\n";
    retVal += "      LotterySimulator -v 10\n";
    retVal += "      LotterySimulator -t 5 10\n";
    retVal += "      LotterySimulator -vt 10 100\n";
    retVal += "      LotterySimulator -vv 100\n";
    retVal += "      LotterySimulator -vvt 5 100\n";
    System.out.println(retVal);
    return retVal;
  }


  public static void main(String [] args)
  {
    final String methodName = CLASSNAME + ": main()";

    if (args.length==0 || args[0].startsWith("-h"))
    {
      printUsage();
      System.exit(1);
    }
    if (args[0].startsWith("-v"))  verbose=true;
    if (args[0].startsWith("-vv"))  verbose2=true;
    if (args[0].startsWith("-t")||args[0].endsWith("t"))
    {
      //verbose = true;
        // LotterySimulator( numDraws, tixPerDraw)
      new LotterySimulator(Integer.parseInt(args[args.length-1]),Integer.parseInt(args[1]));
    }
    else new LotterySimulator(Integer.parseInt(args[args.length-1]), 1);

    if (log_ != null) log_.endMethod();
  }


  private boolean someoneWonTheJackpot()
  {
    boolean retVal = false;
    int numSold = Math.round(getNumTicketsSold(pool));
    for (int i = 0; !retVal && i< numSold; i++)
      retVal = Math.random()<sixesChance;
    return  retVal;
  }


  /** gets the number of tix sold based on the pool size. This is a non-linear relationship.
  **/
  private long getNumTicketsSold(int poolSize)
  {
    float multiplier = 3.0f;
    long retVal = ((long)((float)poolSize * 0.75f/multiplier));
    if  (poolSize>50000000)
      retVal = ((long)((float)poolSize * 1.8f/multiplier));
    else if (poolSize>45000000)
      retVal =  ((long)((float)poolSize * 1.8f/multiplier));
    else if (poolSize>40000000)
      retVal =  ((long)((float)poolSize * 1.6f/multiplier));
    else if (poolSize>30000000)
      retVal =  ((long)((float)poolSize * 1.3f/multiplier));
    else if (poolSize>20000000)
      retVal =  ((long)((float)poolSize * 1.1f/multiplier));
    else if (poolSize>10000000)
      retVal =  ((long)((float)poolSize * 1.0f/multiplier));
    else if (poolSize>6000000)
      retVal =  ((long)((float)poolSize * 0.8f/multiplier));

    return retVal;

  }


  /**  Inits the log and the payout amounts for the different prize levels.*/
  private void initClass()
  {
    final String methodName = CLASSNAME + ": initClass()";

    if (!initClass || log_ == null)
    {
      log_ = Log.getInstance();
      if (log_ != null)
      {
        log_.setLogLevel(Log.MAJOR);
        log_.startMethod(methodName);
      }
      log_.debug("Into the init block");
      CLASSPATH = System.getProperty("java.class.path");
      ones = 0;
      twos = 0;
      twosPlus = 0;
      threes = 0;
      fours = 0;
      fives = 0;
      fivesPlus = 0;
      sixes = 0;

      onesChance = 1/numbers + 1/(numbers-1) + 1/(numbers-2) + 1/(numbers-3) + 1/(numbers-4) + 1/(numbers-5);
      twosChance = (float)(1.0/20.0);
      twosPlusChance = (float)(1.0/81.2);
      threesChance = (float)(1.0/56.7);
      foursChance = (float)(1.0/1033.0);
      fivesChance = (float)(1.0/55492.0);
      fivesPlusChance = (float)(1.0/2330636.0);
      sixesChance = (float)(1.0/13983816.0);

      calculatePayouts(pool);

      if (verbose2) System.out.println("Chance Payouts: 6("+sixesChance+") "+
                  Math.round(0.805*pool) +"/"+ Math.round(getNumTicketsSold(pool)* sixesChance)+"="+
                  sixesPay);
      if (verbose2) System.out.println("Chance Payouts: 5bonus("+fivesPlusChance+") "+
                  Math.round(0.0575*pool) +"/"+ Math.round(getNumTicketsSold(pool)* fivesPlusChance)+"="+
                  fivesPlusPay);
      if (verbose2) System.out.println("Chance Payouts: 5("+fivesChance+") "+
                  Math.round(0.0475*pool) +"/"+ Math.round(getNumTicketsSold(pool)* fivesChance)+"="+
                  fivesPay);
      if (verbose2) System.out.println("Chance Payouts: 4("+foursChance+") "+
                  Math.round(0.09*pool) +"/"+ Math.round(getNumTicketsSold(pool)* foursChance)+"="+
                  foursPay);
      if (verbose2) System.out.println("Chance Payouts: 3("+threesChance+") "+
                  10.0 +"/"+ Math.round(getNumTicketsSold(pool)* threesChance)+"="+
                  threesPay);
      initClass = true;

      if (log_ != null) log_.endMethod();
    }
  }


  /* calculates the payouts for the various levels based on the poolsize **/
  private void calculatePayouts(int currentPool)
  {
    int tixSold = Math.round(getNumTicketsSold(currentPool));
    onesPay = 0;
    twosPay = 0;
    twosPlusPay = 5;
    threesPay = 10;
    if (currentPool < 100000000)
    {
      // 4/6 pays a split of 9.5% of the pool
      foursPay = Math.round((0.095*(float)currentPool) /(float)((float)tixSold* foursChance));

      // 5/6 pays a split of 5% of the currentPool
      fivesPay = Math.round((0.05*(float)currentPool) /(float)((float)tixSold* fivesChance));

      // 5/6 with the bonus pays a split of 6% of the currentPool
      fivesPlusPay = Math.round((0.06*(float)currentPool) /(float)((float)tixSold* fivesPlusChance));

      // Jackpot (6/6) pays a split of 80.5 % of the currentPool
      sixesPay = Math.round((0.795*(float)currentPool) /(float)((float)tixSold* sixesChance));
    }
    else
    {
      // no longer used - it used to be pool >30000000

      // 4/6 pays a split of 29% of the pool
      foursPay = Math.round((0.29*(float)currentPool) /(float)((float)tixSold* foursChance));

      // 5/6 pays a split of 15% of the currentPool
      fivesPay = Math.round((0.15*(float)currentPool) /(float)((float)tixSold* fivesChance));

      // 5/6 with the bonus pays a split of 16% of the currentPool
      fivesPlusPay = Math.round((0.16*(float)currentPool) /(float)((float)tixSold* fivesPlusChance));

      // Jackpot (6/6) pays a split of 40 % of the currentPool
      sixesPay = Math.round((0.4*(float)currentPool) /(float)((float)tixSold* sixesChance));
    }
  }


  /**  Counts the number of numbers in v1 match the numbers in v2. */
  private int matches(Vector<Long> v1, Vector<Long> v2)
  {
    final String methodName = CLASSNAME + ": matches()";
    if (log_ != null) log_.startMethod(methodName);

    int retVal = 0;
    for (int i = 0; i < v1.size(); i++)
    {
      if (v2.contains(v1.get(i))) retVal++;
    }

    if (log_ != null) log_.endMethod();
    return retVal;
  }


  /**  Draws on more number as the bonus number from 'nums'
    * numbers and excludes the numbers already drawn and passed in v1.
    * @param v1 is a vector of numbers to exclude (nums already drawn)
    * @param nums the sample size ... 1-nums
    */
  private long drawBonusNumber(Vector v1, int nums)
  {
    final String methodName = CLASSNAME + ": drawBonusNumber()";
    if (log_ != null) log_.startMethod(methodName);

    long randLong = Math.round(Math.random()*nums)+1;
    while (v1.contains(randLong))
    {
      randLong  = Math.round(Math.random()*nums)+1;
    }
    if (log_ != null) log_.endMethod();
    return randLong;
  }


  /**  Rolls 'numDice' each with 'nums' sides and returns the results in a Vector of Longs.*/
  private Vector<Long> rollDice(int numDice, int nums)
  {
    final String methodName = CLASSNAME + ": rollDice("+numDice+", "+nums+")";
    if (log_ != null) log_.startMethod(methodName);

    Vector <Long> retVal = new Vector<Long>() ;
    long randLong = 0;
    int i=0;
    while ( i< numDice )
    {
      randLong = Math.round(Math.random()*nums)+1;
      if (!retVal.contains(randLong))
      {
        retVal.add(new Long(randLong));
        i++;
      }
      else
      {
        //System.out.print("DUPE");
      }
    }

    if (log_ != null) log_.endMethod();
    return retVal;
  }

}