//Peter Le
	//Period 2
	//Computer Systems Research
	//First Quarter Simulation Program (Cycle and output)
 
   import java.util.*;
   import java.io.*;
   
    public class Test
   {
      static int MONTHS = 48;	  
      static Citizen[] population;
   
       public static void main(String[] args) throws IOException
      { 
      
      	//read in data for different kinds of classes
         BufferedReader citizenReader = new BufferedReader(new FileReader("citizen.txt"));
         BufferedReader resourceReader = new BufferedReader(new FileReader("resourcepool.txt"));
         BufferedReader govtReader = new BufferedReader(new FileReader("govt.txt"));
         PrintStream p = new PrintStream(new FileOutputStream("results.txt")); //include resourcepool and govt # in output
         PrintStream goutput = new PrintStream(new FileOutputStream("govtracker.txt")); //track wealth over time
         PrintStream coutput = new PrintStream(new FileOutputStream("cittracker.txt")); //ditto
      	
      	
      	//Create population
         int n = Integer.parseInt(citizenReader.readLine());
         Citizen[] people = new Citizen[n];
         for(int i = 0; i<people.length;i++)
         {
            int x = 0;
            double[] d = new double[6];
            StringTokenizer st = new StringTokenizer(citizenReader.readLine());
            while (st.hasMoreTokens()) {
               String s = st.nextToken();
               d[x] = Double.parseDouble(s);
               x++;
            }
         
            people[i] = new Citizen(d[0], d[1], d[2], d[3], d[4], d[5]);
         }
         citizenReader.close();
      
      	//for now just read one Government, later use more for multiple tests
         n = Integer.parseInt(govtReader.readLine());
         Government[] govts = new Government[n];
         for(int y = 0; y<govts.length;y++)
         {
            int x = 0;
            double[] d = new double[11];
            StringTokenizer st = new StringTokenizer(govtReader.readLine());
            while (st.hasMoreTokens()) {
               String s = st.nextToken();
               d[x] = Double.parseDouble(s);
               x++;
            }
         
            govts[y] = new Government(d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10]); //d[0] will be index
         }
         govtReader.close();
      
      	//for now one ResourcePool, later use more for multiple tests?
         n = Integer.parseInt(resourceReader.readLine());
         ResourcePool[] pools = new ResourcePool[n];
         for(int ya = 0; ya<pools.length;ya++)
         {
            String str = resourceReader.readLine();
            double monies = Double.parseDouble(str);
            ResourcePool tempPool = new ResourcePool(monies);
            pools[ya] = tempPool;
         }
         resourceReader.close();
         population = people;
         iterate(MONTHS, govts,people,pools, p, goutput, coutput);
      		
      }
      
      
       public static void iterate(int time, Government[] govts, Citizen[] people2, ResourcePool[] pools, PrintStream p, PrintStream goutput, PrintStream coutput) 
      {
         String[] output = new String[(pools.length)*(govts.length)];
      
      //Work on timeframe (every month tax?)
      //govts[0], pools[0], people
         int ccount = 0;
         int gcount = 0;
      	
         int gv = 0;
         int rp = 0;
         
         double rating;
         double[] cwealth = new double[49];
         double[] gwealth = new double[49];
      	
         for(int meh = 0;meh<people2.length;meh++) //initial wealth count
         {
            cwealth[ccount] += people2[meh].getWealth();
         }
      	
         gwealth[gcount] = govts[gv].getWealth(); 
      	
      	
         for(int i = 0;i<time;i++) //start the cycle, no multiple govts/resources now
         {
            boolean wellfair = false;
            Government g1 = govts[gv];
            rating = 0;
            if(g1.oldApproval()<g1.approvalRating()) //very simple right now, maybe do govt assessment of "need"
            {          
               if(Math.random()<g1.response())
                  wellfair = true;
            }      
            double oldemoney = g1.getWealth();
         	
            ccount++;
         	/*********************************************************************************/
            for(int cv = 0;cv<people2.length;cv++)//civ cycle
            {
               Citizen p1 = people2[cv];
               double oldwealth = p1.getWealth();
            	
            	//receive benefits
               if(wellfair=true)
               {
                  p1.wealth(g1.welfare());
                  //p1.health(g1.welfare());
                  g1.wealth(-g1.welfare());
                  pools[rp].subResources(g1.welfare());
               }
            	//work + taxes
               p1.wealth(p1.getWorkRate()*p1.getWealth());
               p1.wealth(-g1.taxRate()*p1.getWealth());
               g1.wealth(g1.taxRate()*p1.getWealth());
               
            	//spending
               p1.wealth(-p1.getSpending()*p1.getWealth());
					p1.wealth(-p1.getSpending()*g1.getSalesTax());
					g1.wealth(p1.getSpending()*g1.getSalesTax());
               pools[rp].addResources(p1.getWorkRate()-p1.getSpending());
         	 
               //consumption
               pools[rp].subResources(p1.getSpending());
               p1.wealth(-p1.getSpending());
               p1.health(p1.getSpending()+p1.getHealth()); 
            	
            	//health and final happinesss stuff here
               p1.health(-1*3*(Math.random())); //natural degradation
               if(p1.getHappiness()>100.0)
                  p1.happy(100.0);
               if(p1.getHealth()>100.0)
                  p1.health(100.0);
             
               double assessW;
               //System.out.println(oldwealth + " " + p1.getWealth());
               assessW = assessWealth(oldwealth, p1.getWealth(), p1.judgeWealth()); //wealth ratio
               p1.rateW(assessW);
               System.out.println(assessW);
            	
               p1.happy((assessW+p1.getHealth())/2); //messed up
               rating += p1.getApproval(); //messed up
               
               cwealth[ccount] += p1.getWealth();
            	     
            } //pay and interact then update govt standing and output + resources
            /*********************************************************************************/
         	
            //System.out.println(pools[rp].getResources());
            rating /= people2.length; //average of approvals = approval rating
            g1.changeApproval(rating);
          
          	//Start government cycle  
            double w;
            w = assessWealth(oldemoney,g1.getWealth(),g1.judgeWealth());
            g1.rateW(w);
            g1.happy((w+g1.getHealth()+g1.approvalRating())/3);
         	
         	//"[resource] [govt] [rating]"
            output[gv] = (rp + " " + gv + " " + g1.getHappiness()); //update approval each time
         
            gcount++;
            gwealth[gcount] = g1.getWealth(); //track gwealth
         
         }
      	
         printOut(output, p); //print output
         printOutGovtCycle(goutput, gv, rp, gwealth);
         printOutCitizenCycle(coutput, gv, rp, cwealth);
      }
      
       public static void printOut(String[] s, PrintStream printer)
      {
         printer.println(s.length);
         for(int x = 0;x<s.length;x++)
         {
            printer.println(s[x]);
         }
      
      }
      
       public static void printOutGovtCycle(PrintStream printer, int gnum, int rnum, double[] gwealth) //print progress of wealth
      {
         for(int x = 0;x<gwealth.length;x++)
         {
            printer.println(x + " " + gnum + " " + rnum + " " + gwealth[x]);
         }
      }
   	
       public static void printOutCitizenCycle(PrintStream printer, int gnum, int rnum, double[] cwealth) //print progress of wealth stats
      {
         for(int x = 0;x<cwealth.length;x++)
         {
            printer.println(x + " " + gnum + " " + rnum + " " + cwealth[x]);
         }
      }
   	   
       public static double assessWealth(double beforeW, double afterW, double WA) //need relative wealth measure
      {
         double measureW = 0;
      
         measureW = afterW/beforeW;
         if(WA>1)
            measureW = measureW*(WA); 
         else
            measureW = -measureW*(WA);
            
         return measureW;
      }
   	
   	
   }