import pygame
from precode2 import Vector2D
from random import randint
import math

SPEED_LIMITTOP = 5
SPEED_LIMITBOT = -5

class Flyer():

    def __init__(self, radius, pos, color, speed):
        self.radius = radius
        self.pos = pos
        self.color = color
        self.speed = speed


class Boids(Flyer):

    def __init__(self, radius, pos, color, speed):
        Flyer.__init__(self, radius, pos, color, speed)

    def draw(self, screen):
        pygame.draw.circle(screen, self.color ,(int(self.pos.x), (int(self.pos.y))),10)

    def move(self):
        self.pos.x += self.speed.x
        self.pos.y += self.speed.y

    def walls(self):
        if self.pos.x >= 1240:
            self.speed.x -= 7
        if self.pos.x <= 40:
            self.speed.x += 7
        if self.pos.y >= 680:
            self.speed.y -= 7
        if self.pos.y <= 40:
            self.speed.y += 7

    def speed_check(self, boidlist):

        if self.speed.x > SPEED_LIMITTOP:
            self.speed.x = SPEED_LIMITTOP
        if self.speed.y > SPEED_LIMITTOP:
            self.speed.y = SPEED_LIMITTOP

        if self.speed.x < SPEED_LIMITBOT:
            self.speed.x = SPEED_LIMITBOT
        if self.speed.y < SPEED_LIMITBOT:
            self.speed.y = SPEED_LIMITBOT

    def rule1(self, boidlist):

        close_boids = []
        sum_x = 0
        sum_y = 0

        #Legge i egen funksjon
        for element in boidlist:
            if element is not self:
                distance = self.pos - element.pos
                if distance.__abs__() < 100:
                    close_boids.append(element)

        # Check if list is greater than 1
        if len(close_boids) >= 1:
            for boid in close_boids:
                sum_x += self.pos.x - boid.pos.x
                sum_y += self.pos.y - boid.pos.y

        try:
            avgpos_x = sum_x / len(close_boids)
            avgpos_y = sum_y / len(close_boids)

            normalized = math.sqrt((avgpos_x*avgpos_x)+(avgpos_y*avgpos_y))

            normalx = avgpos_x/normalized * SPEED_LIMITTOP
            normaly = avgpos_y/normalized * SPEED_LIMITTOP

            self.speed.x -= normalx
            self.speed.y -= normaly

        except:
            ZeroDivisionError

    def rule2(self, boidlist):

        close_boids = []
        sum_x = 0
        sum_y = 0

        #Legge i egen funksjon
        for element in boidlist:
            if element is not self:
                distance = self.pos - element.pos
                if distance.__abs__() < 100:
                    close_boids.append(element)

        if len(close_boids) > 0

    def rule3(self, boidlist):

        close_boids = []
        sum_x = 0
        sum_y = 0

        #Legge i egen funksjon
        for element in boidlist:
            if element is not self:
                distance = self.pos - element.pos
                if distance.__abs__() < 100:
                    close_boids.append(element)

        # Check if list is greater than 1
        if len(close_boids) >= 1:
            for boid in close_boids:
                sum_x += boid.speed.x
                sum_y += boid.speed.y

        try:
            avg_x = sum_x / len(close_boids)
            avg_y = sum_y / len(close_boids)

            normalized = math.sqrt((avg_x*avg_x)+(avg_y*avg_y))

            normalx = avg_x/normalized * SPEED_LIMITTOP
            normaly = avg_y/normalized * SPEED_LIMITTOP

            self.speed.x += normalx
            self.speed.y += normaly

        except:
            ZeroDivisionError


        # Boids change color if close to each other
        #if len(close_boids) > 1:
        #    for element in close_boids:
        #        element.color = (0,0,250)



class Hoiks(Boids):

    def __init__(self, radius, pos, color, speed):
        Flyer.__init__(self, radius, pos, color, speed)

class Game():

    def __init__(self):
        pygame.init()
        self.screen = pygame.display.set_mode((1280, 720))
        self.clock = pygame.time.Clock()

        self.done = False
        self.boidlist = []

        for i in range(15):
            self.boid = Boids(8, Vector2D(randint(0,640),randint(0,480)), ((255,0,0)), Vector2D(randint(5,10),randint(5,6)))
            self.boidlist.append(self.boid)


    def run(self):
        while not self.done:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.done = True

            self.timepassed = self.clock.tick(30)
            self.screen.fill((150,150,0))

            for i in self.boidlist:
                i.rule1(self.boidlist)
                i.rule3(self.boidlist)
                i.speed_check(self.boidlist)
                i.walls()
                i.move()
                i.draw(self.screen)

            pygame.display.flip()

if __name__ == '__main__':
    game = Game()
    game.run()