import datetime
import math
import numpy as np
import random
import pygame

from brain import Neural_Network
from params import (
    GY,
    CAR_MAX_SPEED,
    CAR_MAX_FITNESS,
    CAR_SIZE,
    CAR_STEERING_FACTOR,
    MAX_RUN_TIME,
    VISION_LENGTH,
    VISION_SPAN,
    THROTTLE_POWER,
    screen,
)
from trigo import angle_to_vector, get_line_feats, segments_intersection, distance

IMG = pygame.image.load("car20.png")  # .convert()


class Car(pygame.sprite.Sprite):
    def __init__(self, brain=None):
        pygame.sprite.Sprite.__init__(self)
        self.top_surface = pygame.Surface((CAR_SIZE, CAR_SIZE))
        self.original_image = IMG
        # self.image = pygame.Surface((CAR_SIZE, CAR_SIZE))
        # self.image.fill((0,255,0))
        # self.original_image = self.image

        self.image = self.original_image

        self.rect = self.image.get_rect()
        self.vision_length = VISION_LENGTH  # line liength
        self.vision_span = VISION_SPAN  # degrees
        self.draw_sensors = False

        # lets add 3 sensors as a start
        # 1 straight ahead
        # 2 left 15°
        # 3 right 15 °
        # we will give each of them a max lenght to
        # and we will eventually detect any line crossing the sensor and
        # retain the min value as a distance to collision input
        self.center_sensor = None
        self.left_sensor = None
        self.right_sensor = None
        self.sensors = [self.left_sensor, self.center_sensor, self.right_sensor]
        self.probes = [self.vision_length] * 3

        if brain:
            self.brain = brain
        else:
            self.brain = Neural_Network()

        self.reset_car_pos()
        self.update_sensors()
        self.probe_brain()
        self.run = True
        self.distance_run = 0
        self.creation_dt = datetime.datetime.now()
        self.run_time = 0

    def reset_car_pos(self):
        self.rect.center = (
            75 - int(random.random() * 20) - 10,
            GY - 50 - int(random.random() * 20) - 10,
        )
        self.speed = 1
        self.heading = random.random() * 20
        self.heading_change = random.random() * 30

    def update_sensors(self):
        center = self.rect.center
        vc = angle_to_vector(self.heading)
        self.center_sensor = [
            center,
            (
                int(self.vision_length * vc[0] + center[0]),
                int(-self.vision_length * vc[1] + center[1]),
            ),
        ]

        vl = angle_to_vector(self.heading + self.vision_span)
        self.left_sensor = [
            center,
            (
                int(self.vision_length * vl[0] + center[0]),
                int(-self.vision_length * vl[1] + center[1]),
            ),
        ]

        vr = angle_to_vector(self.heading - self.vision_span)
        self.right_sensor = [
            center,
            (
                int(self.vision_length * vr[0] + center[0]),
                int(-self.vision_length * vr[1] + center[1]),
            ),
        ]

    def update_position(self):
        vec = angle_to_vector(self.heading)
        old_center = self.rect.center
        self.rect.center = (
            self.speed * vec[0] / 2 + old_center[0],
            -self.speed * vec[1] / 2 + old_center[1],
        )
        self.update_sensors()
        if self.run:
            self.distance_run += int(distance(old_center, self.rect.center))
            self.brain.fitness = math.sqrt(self.distance_run)

    def probe_lines_proximity(self, lines):
        # print(self.center_sensor, lines[0])
        self.probes = [self.vision_length * 2] * 3
        for idx, sensor in enumerate(
            [self.left_sensor, self.center_sensor, self.right_sensor]
        ):
            for line in lines:
                ip = segments_intersection(sensor, line)
                # print(ip)
                if ip:
                    if self.draw_sensors:
                        pygame.draw.circle(screen, (125, 125, 255), ip, 4, 2)
                    dist = int(distance(ip, self.rect.center))
                    self.probes[idx] = min(dist, self.probes[idx])
                    if dist < 1 * self.speed or self.speed < 0.01:
                        self.run = False
                        self.speed = 0
                        # print(f'Car {id(self)} crashed')
                        return

                else:
                    self.probes[idx] = self.vision_length * 1.1
        # print(self.probes)

    def probe_brain(self):
        res = self.brain.predict(np.array(self.probes + [self.speed]))
        self.heading_change = res[0] * 30
        self.throttle = res[1] * 5

    def update(self):
        # rotate
        old_center = self.rect.center
        self.image = pygame.transform.rotate(self.original_image, self.heading)
        self.rect = self.image.get_rect()
        self.rect.center = old_center
        self.update_position()
        self.run_time = (datetime.datetime.now() - self.creation_dt).seconds
        if self.run_time > MAX_RUN_TIME:
            print("RUNTIME EXCEEDED")
        if (
            self.speed < 0.01
            or self.brain.fitness > CAR_MAX_FITNESS
            or self.run_time > MAX_RUN_TIME
        ):
            self.run = False
            # print(f"Car {id(self)} crashed")
        # print(
        #     'id', id(self),
        #     'Speed', self.speed,
        #     'heading', self.heading,
        #     'throttle', self.throttle,
        #     'heading change', self.heading_change,
        # )

        if self.speed:
            self.heading += self.heading_change * CAR_STEERING_FACTOR / self.speed
            self.heading = self.heading % 360

            self.speed += self.throttle  # THROTTLE_POWER
            # if self.throttle :
            # self.speed += self.throttle #THROTTLE_POWER
            # else :
            # self.speed -= self.throttle #THROTTLE_POWER

            self.speed = max(0, self.speed)
            self.speed = min(self.speed, CAR_MAX_SPEED)

        super().update()

    def show_features(self):
        if self.draw_sensors:
            pygame.draw.line(
                screen, (255, 0, 0), self.center_sensor[0], self.center_sensor[1]
            )
            pygame.draw.line(
                screen, (0, 255, 0), self.left_sensor[0], self.left_sensor[1]
            )
            pygame.draw.line(
                screen, (0, 0, 255), self.right_sensor[0], self.right_sensor[1]
            )
            pygame.draw.circle(screen, (125, 255, 125), self.rect.center, 4, 2)