import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.stream.IntStream;

public class ParkingLotManagement {
    public static void main(String[] args) {
        ParkingLot myParkingLot = new ParkingLot("Beverli");
        Scanner jin = new Scanner(System.in);
        System.out.println("Enter vehicle information that is entering the parking.\n" +
                "This includes the vehicle ID, hours of stay, whether the vehicle is a truck(T) or a car(C)," +
                "and the floor you wish to park in ! Write END to finish");
        while (true) {
            try {
                String line = jin.nextLine();
                line = line.trim();
                if (line.equals(""))
                    continue;
                if (line.equals("END"))
                    break;
                String[] parts = line.split("\\s+");
                if (parts.length != 4)
                    continue;

                String vehicleID = parts[0];
                int hourStay = Integer.parseInt(parts[1]);
                String vehicleType = parts[2];
                int floor = Integer.parseInt(parts[3]);
                if (vehicleType.equals("C"))
                    myParkingLot.parkVehicle(floor, new Car(vehicleID, hourStay));
                else
                    myParkingLot.parkVehicle(floor, new Truck(vehicleID, hourStay));
            } catch (Exception e) {
            }
        }
        System.out.println(myParkingLot);

        Vehicle testTruck = new Truck("SomeTruck", 2);
        Vehicle testCar = new Car("SomeCar", 1);
        myParkingLot.parkVehicle(2, new Truck("SomeTruck", 5));
        myParkingLot.parkVehicle(2, new Car("SomeCar", 4));
        myParkingLot.parkVehicle(1, new Car("SomeCar2", 2));
        System.out.println(myParkingLot);
        myParkingLot.leaveParking(testCar);
        myParkingLot.leaveParking(testTruck);
        myParkingLot.leaveParking(new Truck("NonExistent truck", 1));
        System.out.println(myParkingLot);
    }
}

class FileSaver{
    public static File saveFile=new File("Parking Backup!");
}

//EXCEPTIONS
class InvalidFloorNumber extends Exception {
    private int floor;

    public InvalidFloorNumber(int floor) {
        super("There is no floor with number " + floor + " on the parking!");
        this.floor = floor;
    }

    public int getFloor() {
        return floor;
    }
}

class VehicleNotOnParking extends Exception {
    private Vehicle vehicle;

    public VehicleNotOnParking(Vehicle vehicle) {
        super("Vehicle " + vehicle + " is not in the parking!");
        this.vehicle = vehicle;
    }

    public Vehicle getVehicle() {
        return vehicle;
    }
}

class TruckException extends Exception {
    private Vehicle vehicle;

    public TruckException(Vehicle vehicle) {
        super("Vehicle " + vehicle + " is a truck and can only be parked on floor 1!");
        this.vehicle = vehicle;
    }

    public Vehicle getVehicle() {
        return vehicle;
    }
}

class NoMoreSpotsOnFloor extends Exception {
    private int floorNumber;

    public NoMoreSpotsOnFloor(int floorNumber) {
        super("No more spots on floor " + floorNumber);
        this.floorNumber = floorNumber;
    }

    public int getFloorNumber() {
        return floorNumber;
    }
}
//EXCEPTIONS

abstract class Vehicle {
    private String vehicleID;
    private int hourStay;

    Vehicle(String vehicleID, int initialHourStay) {
        this.vehicleID = vehicleID;
        hourStay = initialHourStay;
    }

    Vehicle() {
    }

    public String getVehicleID() {
        return vehicleID;
    }

    public int getHourStay() {
        return hourStay;
    }

    public void updateHourStay(int addedTime) {
        this.hourStay += addedTime;
    }

    abstract Double pricePerHour();

    abstract String getType();

    abstract boolean canPark(int floor);

    Double totalPay() {
        return pricePerHour() * hourStay;
    }

    @Override
    public String toString() {
        return ((getType().equals("C")) ? "Car " : "Truck ") + vehicleID;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Vehicle vehicle = (Vehicle) o;
        return vehicleID.equals(vehicle.vehicleID);
    }

    @Override
    public int hashCode() {
        return Objects.hash(vehicleID);
    }
}

class Car extends Vehicle {

    public Car(String vehicleID, int initialHourStay) {
        super(vehicleID, initialHourStay);
    }

    public Car() {
    }

    @Override
    Double pricePerHour() {
        return 1.0;
    }

    @Override
    String getType() {
        return "C";
    }

    @Override
    boolean canPark(int floor) {
        return true;
    }
}

class Truck extends Vehicle {

    public Truck(String vehicleID, int initialHourStay) {
        super(vehicleID, initialHourStay);
    }

    public Truck() {
    }

    @Override
    Double pricePerHour() {
        return 5.0;
    }

    @Override
    String getType() {
        return "T";
    }

    @Override
    boolean canPark(int floor) {
        return floor == 1;
    }
}

class Floor {
    private List<Vehicle> vehicles;
    private static int numberOfVehicles = 40;
    private int floorNumber;

    public Floor(int floorNumber) {
        this.floorNumber = floorNumber;
        vehicles = new ArrayList<>(numberOfVehicles);
    }

    public void parkVehicle(Vehicle vehicle) throws NoMoreSpotsOnFloor {
        if (vehicles.size() != numberOfVehicles) {
            vehicles.add(vehicle);
            System.out.println("Vehicle : " + vehicle + " is parked on floor "+floorNumber);
        } else
            throw new NoMoreSpotsOnFloor(floorNumber);
    }

    public void leaveVehicle(Vehicle vehicle) {
        vehicles.remove(vehicle);
        System.out.println("Vehicle : " + vehicle + " is leaving the floor "
                + floorNumber + "!");
    }

    public boolean vehicleOnFloor(Vehicle vehicle) {
        return vehicles.contains(vehicle);
    }

    public int spotsLeft() {
        return numberOfVehicles - spotsTaken();
    }

    public int spotsTaken() {
        return vehicles.size();
    }

    public List<Vehicle> getVehicles() {
        return vehicles;
    }

    public int getFloorNumber() {
        return floorNumber;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Parking floor : ").append(floorNumber).append("\n");
        vehicles
                .forEach(vehicle -> stringBuilder.append(vehicle).append("\n"));

        stringBuilder.append("Free spots: ").append(spotsLeft()).append("/")
                .append(numberOfVehicles);
        stringBuilder.append("\n");
        return stringBuilder.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Floor floor = (Floor) o;
        return floorNumber == floor.floorNumber &&
                vehicles.equals(floor.vehicles);
    }

    @Override
    public int hashCode() {
        return Objects.hash(vehicles, floorNumber);
    }
}

class ParkingLot {
    private List<Floor> floors;
    private static int numberOfFloors = 3;
    private static int saveInteral=60;
    private String parkingName;
    private Double dailyProfit;


    public ParkingLot(String parkingName) {
        this.parkingName = parkingName;
        floors = new ArrayList<>(numberOfFloors);
        IntStream.range(0, numberOfFloors)
                .forEach(index -> floors.add(new Floor(index + 1)));
        dailyProfit=0.0;
    }

    public void parkVehicle(int floor, Vehicle vehicle) {
        try {
            if (floor >= 1 && floor <= numberOfFloors) {
                if (vehicle.canPark(floor)) {
                    floors.get(floor - 1).parkVehicle(vehicle);
                    dailyProfit += vehicle.totalPay();
                }
                else
                    throw new TruckException(vehicle);
            } else
                throw new InvalidFloorNumber(floor);
        } catch (NoMoreSpotsOnFloor | TruckException
                | InvalidFloorNumber noMoreSpotsOnFloor) {
            System.out.println(noMoreSpotsOnFloor.getMessage());
        }
    }

    public void leaveParking(Vehicle vehicle) {
        try {
            Floor neededFloor
                    = floors
                    .stream()
                    .filter(floor -> floor.vehicleOnFloor(vehicle))
                    .findAny()
                    .orElse(null);
            if (neededFloor != null)
                neededFloor.leaveVehicle(vehicle);
            else
                throw new VehicleNotOnParking(vehicle);
        } catch (VehicleNotOnParking vehicleNotOnParking) {
            System.out.println(vehicleNotOnParking.getMessage());
        }
    }

    public int getFreeSpotsInParking() {
        return
                floors
                        .stream()
                        .mapToInt(Floor::spotsLeft)
                        .sum();
    }

    public List<Floor> getFloors() {
        return floors;
    }

    public static int getNumberOfFloors() {
        return numberOfFloors;
    }

    public String getParkingName() {
        return parkingName;
    }

    public Double dailyTotal() {
        return dailyProfit;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(parkingName).append(" :\n\n");
        floors
                .forEach(stringBuilder::append);

        stringBuilder.append("Total free spots: ").append(getFreeSpotsInParking()).append("\n");
        stringBuilder.append("Daily profit: ").append(dailyTotal()).append("\n");

        return stringBuilder.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ParkingLot that = (ParkingLot) o;
        return floors.equals(that.floors) &&
                parkingName.equals(that.parkingName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(floors, parkingName);
    }

    public void periodicSave(){
        //simulate 60 seconds
        saveParking();
    }

    public void saveParking(){
        try (PrintWriter printWriter = new PrintWriter(new FileOutputStream(FileSaver.saveFile))) {
            printWriter.write(this.toString());
            printWriter.flush();
        } catch (FileNotFoundException e) {
            System.out.println(e.getMessage());
        }
    }
}