# -*- coding: utf-8 -*-
import sys


def abs(x):
    if x < 0:
        return -x
    else:
        return x

class Grid:
    def __init__(self, rows, columns):
        self.rows = rows
        self.columns = columns
        self.grid = [[None]*columns]*rows


class Vehicle:
    def __init__(self):
        self.x = 0
        self.y = 0
        self.ride = None
        self.occupied = False
        self.completed_rides = []

    def head_towards(self, pos):
        x = pos[0]
        y = pos[1]
        if self.x < x:
            self.x += 1
        elif self.x > x:
            self.x -= 1
        elif self.y < y:
            self.y += 1
        elif self.y > y:
            self.y -= 1

    def completed_ride(self):
        print("Actual/Goal: ", (self.x, self.y), self.ride.finish)
        return self.x == self.ride.finish[0] and self.y == self.ride.finish[1]

    def is_at_startpoint(self):
        return self.x == self.ride.start[0] and self.y == self.ride.start[1]

    def tostr(self):
        return "Vehicle at " + str(self.x) + "," + str(self.y)

class Ride:
    def __init__(self, index, start, finish, earliest_start, latest_finish):
        self.index = index
        self.skipable = False
        self.start = start
        self.finish = finish
        self.earliest_start = earliest_start
        self.latest_finish = latest_finish
        self.left_steps = abs(start[0] - finish[0]) + abs(start[1] - finish[1])
        self.completed = False

class Task:
    def __init__(self, filename):
        self.filename = filename
        self.parsed_file = self.__split()
        self.grid = Grid(int(self.parsed_file[0][0]), int(self.parsed_file[0][1]))
        self.rides = []
        self.vehicles_count = int(self.parsed_file[0][2])
        for x in range(1, len(self.parsed_file)):
            y = self.parsed_file[x]
            self.rides.append(
                Ride(x,
                    (int(y[0]), int(y[1])),
                    (int(y[2]), int(y[3])),
                    int(y[4]),
                    int(y[5])
                )
            )

    def __split(self):
        with open(self.filename, "r") as input:
            return [x.split(" ") for x in input.read().splitlines()]

    def simulate_dumb(self):
        step = 1
        for r in self.rides:
            r.active = False
        self.vehicles = []
        for i in range(self.vehicles_count):
            self.vehicles.append(Vehicle())
        while len(self.rides) != 0:
            print("===STEP", step)
            for r in range(len(self.rides)):
                print(self.rides[r].left_steps)
            if step > 100:
                break
            # STEP FUNCTION

            print("List of rides:")
            for r in self.rides:
                print(r.index)

            # Which Vehicle to take for which ride next?
            step += 1
            for r in range(len(self.rides)):
                if not self.rides[r].active:
                    for v in range(len(self.vehicles)):
                        if not self.vehicles[v].occupied:
                            self.vehicles[v].occupied = True
                            self.vehicles[v].ride = self.rides[r]
                            self.vehicles[v].ride.active = True
                            print("taking vehicle", v, "for ride", r+1)
                            print("start:", self.rides[r].start, "finish", self.rides[r].finish)
                            break

            for v in range(len(self.vehicles)):
                line = self.vehicles[v].tostr()
                if self.vehicles[v].ride is not None:
                    line += " with ride " + str(self.vehicles[v].ride.index)
                print(line)

            # Move forward
            for v in range(len(self.vehicles)):
                if self.vehicles[v].ride is not None:
                    if not self.vehicles[v].ride.active:
                        print("Not active: ", v)
                        if self.vehicles[v].is_at_startpoint():
                            # Wait at starting point, then activate the ride
                            if step >= self.vehicles[v].ride.earliest_start:
                                self.rides[r].active = True
                        else:
                            self.vehicles[v].head_towards(self.vehicles[v].ride.start)
                    elif not self.vehicles[v].completed_ride():
                        self.vehicles[v].head_towards(self.vehicles[v].ride.finish)
                        x = self.vehicles[v].x
                        y = self.vehicles[v].y
                        finish = self.vehicles[v].ride.finish
                        self.rides[r].left_steps = abs(x - finish[0]) + abs(y - finish[1])
                    elif self.vehicles[v].completed_ride():
                        print(print(self.vehicles[v].tostr() + " has not moved because it has reached target"))
                        print("Ride", self.vehicles[v].ride.index, "is completed")
                        self.vehicles[v].ride.active = False
                        self.vehicles[v].occupied = False
                        self.vehicles[v].completed_rides += [self.vehicles[v].ride]
                        self.vehicles[v].ride = None
                        self.rides[r].left_steps = 0
                        self.rides[r].completed = True
                        # ToDo Points

            for r in reversed(range(len(self.rides))):
                if not self.rides[r].active:
                    if self.rides[r].completed:
                        print("Delete ", r+1)
                        del(self.rides[r])

            print("List of rides:")
            for r in self.rides:
                print(r.index)

if __name__ == "__main__":
    asd = Task(sys.argv[1])
    asd.simulate_dumb()
    print("Vehicles:", len(asd.vehicles))
    for v in range(len(asd.vehicles)):
        line = str(v+1)
        for r in asd.vehicles[v].completed_rides:
            line += " " + str(r.index)
        print(line)

# vim: tabstop=8 softtabstop=0 expandtab shiftwidth=4 smarttab