#!/usr/local/bin/python3
import numpy as np
import multiprocessing as mp
import random
import statistics


#types of issue:
#How complex an issue is - how long to go from a shallow understanding to a deep understanding
#Each issue could have many solutions - we'll approximate that as a number (opinion), then quantise when we 'vote'
#How many solutions there could be - e.g. 1 - 2 - 10
#
#How the issue is split accross individuals (who believes in what solution)
#
#Individuals:
#How ‘deeply’ they understand the issue (how long it would take to understand the issue)
#How ‘stuck’ individuals are of their view
#How persuasive people are
#
#Who interacts, with whom, when, and how.





issues_spec= [{"name":"a", "complexity":60, "solutions":5}]*2+\
             [{"name":"b", "complexity":30, "solutions":3}]*3

population_spec = \
                  [{"name":"mp", \
                    "opinion":{"a":30, "b":80}, \
                    "understanding":{"a":20,"b":90}, \
                    "eliquence":{"a":10,"b":60}, \
                    "attain":90 \
                  }]*650 \
                  +\
                  [{"name":"voters", \
                    "opinion":{"a":60,"b": 20}, \
                    "understanding":{"a":20,"b":20}, \
                    "eliquence":{"a":70,"b":30}, \
                    "attain":30 \
                  }]*66000


df=10

def randomdist(offset):
    while 1:
        r=np.random.noncentral_chisquare(df, offset)
        if (r<100 and r>=0) : break
    return r

class issue:
    def __init__(self, spec, _i):
        self.name = spec["name"]
        self.i=_i
        self.complexity=randomdist(spec["complexity"])
        self.solutions=int(randomdist(spec["solutions"]+1))

issues=[]
i=0
for spec in issues_spec:
    issues.append(issue(spec, i))
    i+=1

class view:
    def __init__(self, spec, issue):
        self.issue=issue
        self.opinion=randomdist(spec["opinion"][issue.name])
        self.understanding=randomdist(spec["understanding"][issue.name])
        self.eliquence=randomdist(spec["eliquence"][issue.name])

class agent:
    def __init__(self, spec,_i):
        self.name = spec["name"]
        self.i=_i
        self.views=[];
        for issue in issues:
            self.views.append(view(spec, issue))
        self.attain=randomdist(spec["attain"])
        self.trust={}; # agents that we end up trusting or distructing

    def interact(self, speaker, issue):
        #        Agents opinion is changed by speaker, towards the speakers point of view if the elequence of the speaker is high, if the agent has trust in the speaker,  if the agents understanding is low, at the speed that the agent attains.
        mv=self.views[issue.i]
        sv=speaker.views[issue.i]
        # If the speaker is ore eliquent than my current understanding, then I learn, otherwise, I ignore
        changeby=0
        if speaker in self.trust:
            trust=self.trust[speaker]
        else:
            trust=0
        if (sv.eliquence > mv.understanding):
            changeby = randomdist((((sv.eliquence + trust - mv.understanding)*self.attain)/issue.complexity)/10)
            mv.understanding = mv.understanding + abs(changeby)
            if (changeby>0) :
                mv.opinion = ((mv.opinion) + (sv.opinion * changeby))/ (changeby+1)
        if speaker in self.trust:
            self.trust[speaker]+=changeby/10
        else:
            self.trust[speaker]=changeby/10

def addTrust(agents, trusted, value):
    for trustagent in trusted:
        for agent in agents:
            if trustagent in agent.trust:
                agent.trust[trustagent]+=value
            else:
                agent.trust[trustagent]=value

def print_votes(agents, issues):
    for p in agents:
        votes=[[]]
        for issue in issues:
            votes.insert(issue.i,[0]*issue.solutions)

        happyness=[]
        htotal=0
        for issue in issues:
            opinions=[]
            for a in agents[p]:
                opinions.append(a.views[issue.i].opinion)
                solution=(int(a.views[issue.i].opinion / (100/issue.solutions)))
                if (solution>=0 and solution<issue.solutions):
                    votes[issue.i][(int(a.views[issue.i].opinion / (100/issue.solutions)))]+=1
                else:
                    print ("Chosen solution outside range for issue :"+issue.name+str(issue.i)+" : "+str(a.views[issue.i].opinion))
            happyness.insert(0,statistics.variance(opinions))

        av_happyness=statistics.mean(happyness)
        for issue in issues:
            print (p+" Votes for issue "+issue.name+str(issue.i)+" : ", end='')
            win=0
            i=0
            for v in votes[issue.i]:
                if v>votes[issue.i][win] :
                    win=i
                print (" "+str(v), end='')
                i+=1
            print (" \t winner: "+str(win)+" \t  happyness: "+str(int(happyness.pop())))
        print ("Average Happyness : "+str(av_happyness))



agents={}
for spec in population_spec:
    agents[spec["name"]]=[];

i=0
for spec in population_spec:
    agents[spec["name"]].append(agent(spec,i))
    i+=1;





print_votes(agents,issues)

#for i in range(10):
#    print (".",end='', flush=True);
#    for mp in random.sample(agents["mp"],20):
#        for issue in issues:
#            for voter in random.sample(agents["voters"],1000):
#                voter.interact(mp, issue)
#print("");


print("sotition")

sortition=random.sample(agents["voters"],100)

addTrust(agents["voters"], sortition, 50)

for i in range(10):
    print (".",end='', flush=True);
    for voter in sortition:
        for mp in random.sample(agents["mp"],10):
            for issue in issues:
                voter.interact(mp, issue)
print("");


for i in range(5):
    print (".",end='', flush=True);
    for sortd in sortition:
        for voter in random.sample(agents["voters"], 1000):
            for issue in issues:
                voter.interact(sortd, issue)
print("");


print_votes(agents,issues)