# -*- coding: utf-8 -*-
"""
Created on Mon Jun 14 20:10:16 2021

@author: Christian
"""
import random
import copy
from datetime import datetime

var1 = 100
var2 = 100
var3 = 10000**1.6
var4 = 20
var5 = 5000
var6 = 0.5
var7 = 4
var8 = 0.005

random.seed(1) 

class Class1:
    def __init__(self, replication, number):
        self.replication = replication * random.uniform(0.9, 1.1)
        self.number = number
    
    
    def child(self):
        if var6>random.uniform(0, 1):
            number = self.number
        else:
            number = random.randint(0,var4-1)

        return Class1(self.replication, number)
        
class Class2:
    def __init__(
            self, 
            number,
            var9, 
            var10,
            var11,
            var12,
            var13,
            var14,
            var15,
            var16,
            var17,
            var18,                        
            var19=False 
            ): 
        self.number = number
        self.var9 = var9

        self.var19=var19
        self.var11 = var11 * (
            1 + random.uniform(-0.01, 0.005)*(20 + len(self.var9)))
        self.var12 = var12 * (
            1 + random.uniform(-0.02, 0.02)*(20 + len(self.var9)))
        self.var13 = var13 * (
            1 + random.uniform(-0.02, 0.02)*(20 + len(self.var9)))


        if (self.var11>var15/var4):
            var11*0.995
        else:
            var11*1.005
            
        self.var10 = var10 *(
            1 + random.uniform(-0.01, 0.005)*(20 + len(self.var9)))
        if (self.var11>var15/var4):
            var11*0.995
        else:
            var11*1.005

        
        self.var16 = var16*(
            1 + random.uniform(-0.011, 0.01)*(20 + len(self.var9)))

        self.var18 = var18*(
            1 + random.uniform(-0.011, 0.01)*(20 + len(self.var9)))

        self.var17 = var17*(
            1 + random.uniform(-0.011, 0.01)*(20 + len(self.var9)))
        
        for var23 in  self.var9:
            if var23.replication>random.uniform(0, 1):
                var9.append(var23.child())
        self.fooClass1s = list(self.var9)
        self.barClass1s = list(self.var9)

        
    def var30(self,var17,var18,var21):
        for var23 in self.fooClass1s:
            if var23.replication>random.uniform(0, var17):
                self.fooClass1s.append(var23.child())
        if not var21:
            for var23 in self.barClass1s:
                if var23.replication>random.uniform(0, var18):
                    self.barClass1s.append(var23.child())

                
    def __str__(self):
        text = '['
        text += str(self.number) + ":" + str(len(self.var9)) 
        text += ']'
        return text

    
    def child(self, var21,var14,var15):
        if (var21):
            var23s = self.var9
        else:
            var23s = self.barClass1s
        
        var22 = Class2(self.number,
                            var23s,
                            self.var10,
            self.var11,
            self.var12,
            self.var13,

            var14,
            var15,
            self.var16,
            self.var17,  
            self.var18,
            self.var19                          
        )
        return var22
    
    def details(self):
        text = str(self)
        text+= " var10:" + str(self.var10)
        text+= " var11:" + str(self.var11)
        text+= " var16:" + str(self.var16)
        text+= " var17:" + str(self.var17)

        print(text)
    
    def var23Count(self):
        return len(self.fooClass1s)

        
class Class3:
    def __init__(
            self, var22somes, var24,
            var25, var1):
        self.var1 = var1
        self.var22somes = var22somes
        self.var21 =  all(chro.var19 for chro in filter(
                lambda var22: var22.number==0, self.var22somes))


        self.age = 0
        self.var26 = False
        
        self.var24 = var24
        self.var25 = var25
        
        self.var17 = sum(var22.var17 for var22 in self.var22somes)
        self.var18 = sum(var22.var18 for var22 in self.var22somes)

        self.var10 = sum(var22.var10 for var22 in self.var22somes)
        self.var11 = sum(var22.var11 for var22 in self.var22somes)
        
    def effectiveUuu(self):
        var13 = sum(var22.var13 for var22 in self.var22somes)
        absoluteUuu = sum(var22.var12 for var22 in self.var22somes)
        return absoluteUuu + var13*self.var35()



    def var30(self):
        self.age+=1
        for var22 in self.var22somes:
            var22.var30(self.var17,self.var18,self.var21)
                
    def transvar23Alive(self):
        return sum(len(var22.fooClass1s) for var22 in self.var22somes)<self.var1

    def var22somesFromParent(self, var42):
        var15 = sum(var22.var11 for var22 in var42.var22somes)/(2*var4)
        var14 = sum(var22.var10 for var22 in var42.var22somes)/(2*var4)
        
        newBoos = []
        
        for i in range(0,var4):
            candidates = list(filter(lambda var22: var22.number==i, var42.var22somes))
            if (len(candidates)!=2):
                for var22 in var42.var22somes:
                    print(str(var22))

            parentBoo = random.choice(candidates)
            newBoos.append(parentBoo.child(var42.var21,var14,var15))


        var9 = []
        map(var9.extend, newBoos)
        for i in range(0,var4):
            newBoos[i].var9 = []
            for var23 in var9:
                if var23.number==i:
                    if var8>random.uniform(0, 1):
                        newBoos[i].var9.append(var23)
        return newBoos

    def var32(self, male):
        var33Boos = self.var22somesFromParent(self)
        var34Boos = self.var22somesFromParent(male)
        
        var24 = (self.var24 + male.var24)/2 *random.uniform(0.99, 1.01)
        var25 = (self.var25 + male.var25)/2 *random.uniform(0.99, 1.01)
        var1 = (self.var1 + male.var1)/2 *random.uniform(0.99, 1.01)
        
        return(Class3(var33Boos+var34Boos,
                          var24,var25,
                          var1))
        
    def var16(self):
        return sum(var22.var16 for var22 in self.var22somes)

    def var16Works(self):
        var16Class1s = []
        map(var16Class1s.extend, (var22.var9 for var22 in self.var22somes))
        
        index = 0
        while (index<5):
            index+=1
            for var23 in var16Class1s:
                if var23.replication>random.uniform(0, self.var16()):
                    var16Class1s.append(var23.child())
        return len(var16Class1s)<self.var1
    
    def __str__(self):
        if (self.var21):
            text =  'Female'
        else:
            text =  'Male'
        text += '['
        text += str(self.age) + '-'
        text += str(self.var23Count()) + '-'
        text += str(round(self.var35()))
        text += ']'
        return text


    
    
    def var35(self):

        return (var5-self.var17) * self.var10 
    
    def details(self):
        print(str(self))
        for var22 in self.var22somes:
            print(var22.details())
            
    def var23Count(self):
        return sum(var22.var23Count() for var22 in self.var22somes)
        
                    
                    
class Class4:
    def __init__(self,var37):
        self.var36 = []
        self.var37 = var37
        self.averageFit = self.averageFitness()
        self.var39 = []

        self.maleCandidates = []
        self.nextClass4 = []
        self.deathBefore15 = 0
        self.deathBefore1 = 0

        self.transvar23Death = 0
        
        for var42 in self.var37:
            var42.var30()
            
            var41 = False
            prob = len(var37)**(len(var37)/1000)/(var3)*var42.var11
            if (var42.age<=1):
                prob = prob*1
            elif (var42.var26):
                prob = prob*2
            elif (1<var42.age<=5):
                prob = prob*1
            elif (5<var42.age<15):
                prob = prob*1

                
            if prob > random.uniform(0, 1):
                var41=True
            else:
                var41 = False
            
            if var42.transvar23Alive() and not var41:
                self.nextClass4.append(var42)
                if var42.var21:

                    var42.var26 = False
                    

                    var35 = var42.var35()*random.uniform(0.8, 1.2)

                    if 12< var42.age <var42.var24 and var35>self.averageFit:
                        self.var39.append(var42)

                else:
                    var35 = var42.var35()*random.uniform(0.5, 1.5)
                    if 12< var42.age <var42.var25 and var35>self.averageFit:
                        self.maleCandidates.append(var42)
            else:
                self.var36.append(var42)
                if (var42.age==1):
                    self.deathBefore1+=1
                if (var42.age<15):
                    self.deathBefore15+=1
                if not var42.transvar23Alive():
                    self.transvar23Death+=1
            
        
        for female in self.var39:

            self.var44(female)
                
            
        self.averageDeath = sum(var42.age for var42 in self.var36)/(len(self.var36)+0.001)
    def listClass4(self):
        text = "["
        for var42 in self.var37:
            text+=str(var42)+", "
        print(text)


    def var44(self,female):
        if len(self.maleCandidates)==0:
            print('no fit males')
        else:
            for season in range(1, var7):
                male = random.choice(self.maleCandidates)
                if (male.var35()<female.effectiveUuu()):
                    continue
                child = female.var32(male)
                if (child.var16Works()):
                    self.nextClass4.append(child)
                    female.var26 = True
                    break

            
    def averageFitness(self):
        if (len(self.var37)==0):
            return 0
        else:
            return sum(individual.var35() for individual in self.var37)/len(self.var37)

    def averageLifespan(self):
        if (len(self.var37)==0):
            return 0

        return sum(individual.calcLifespan() for individual in self.var37)/len(self.var37)
    def averageAge(self):
        if (len(self.var37)==0):
            return 0

        return sum(individual.age for individual in self.var37)/len(self.var37)
    def averageClass1s(self):
        if (len(self.var37)==0):
            return 0

        return sum(individual.var23Count() for individual in self.var37)/len(self.var37)


    def __len__(self):
        return len(self.var37)
            
    def __str__(self):
        text = "Count:" + str(len(self.var37)) 

        return text
    
    def next(self):
        return Class4(self.nextClass4)
    
    def var45(self):
        sum(self.var37[i].var17 for i in range(0,len(self)))/len(self)
        
            
def initialPopuation():
    population = []
    for sex in [True,False]:
        for index in range(0,500):
            var22somes = []
            for i in range(0, var4):
                var9 = [Class1(0.1,i) for i in range(0,1)]
                for k in range(0,2):
                    var22somes.append(Class2(
                        i,
                        var9,
                        1,
                        1,
                        1500,
                        0.3/var4,
                        var4,
                        var4,
                        5,
                        5,         
                        1,
                        var19=sex
                    ))
                
            var42 = Class3(var22somes,30,50,var1)
            population.append(var42)
    return Class4(population)

year = 0
population = initialPopuation()
populationCount = []
lastDisplay= datetime.now()


while(year<1000000):
    year+=1
    population = population.next()
    populationCount.append(len(population))
    
    if (year%10==0 or (lastDisplay-datetime.now()).total_seconds()>60):
        lastDisplay = datetime.now()
        print("Year:" + str(year) + ": " + str(population))