using System;

public class Program

{

    //TO-DO - create the following 3 classes

    //* Motorcycle

    //* Car

    //* Truck

    //...and any more extra classes as necessary to create an ideal class structure that will fulfill the following criteria:

    //* All 3 classes must implement interface IVehicle

    //* All 3 classes must have a name passed in at construction, that then cannot be changed

    //* When the Specs function is called on any Vehicle, it should get passed into the function GetSpecsStringForVehicle() and the result should be returned

    //* The LoadCargo setter should check the size and weight of the cargo and then:

    //IF either the size OR the weight of the cargo is greater than the capacity of the vehicle, then call Cargo.ReportLoadingAttempt, pass in succeeded = false and then make no changes to the vehicle

    //ELSE assign the cargo value to the vehicle and call Cargo.ReportLoadingAttempt and pass in succeeded = true

    //* The LoadCargo getter should return the current cargo value loaded on the vehicle (i.e. the last cargo that was successfully assigned using the setter)

    //*** Motorcycle Class: ***/

    //CONSTRUCTOR: Motorcycle(string name)

    //All motorcycles will have 2 wheels, 0 doors, 1 seat and have a max cargo capacity of Weight 10, Size 10

    //*** Truck class: ***/

    //CONSTRUCTOR: Truck(string name, int wheels)

    //All trucks will have 2 doors, 3 seats and a max cargo capacity of Weight 1000, Size 1000.

    //Trucks can have different numbers of wheels, specified upon construction and cannot be changed afterwards.

    //The number of wheels cannot be less than 4

    //If less than 4 wheels are specified, throw an Exception with the message "Trucks can't have less than 4 wheels"

    //*** Car class: ***/

    //CONSTRUCTOR: Car(string name, int doors, int seats, int maxCargoSize, int maxCargoWeight)

    //All cars have 4 wheels, but all others aspects of a car (doors, seats and max cargo capacity) can be defined on construction (but then cannot be changed afterwards)

    //Cars cannot have more than 7 doors (otherwise throw Exception: "Number of doors specified too much for any car")

    //Cars cannot have more than 10 seats (otherwise throw Exception: "Number of seats specified too much for any car")

    //No car can have a cargo capacity of more than Weight 100 or Size 100. (If either is specified as too big, throw Exception "Max cargo size or weight specified too big for any car")

    //Once all the classes have been created as specified above, the task is complete when the program is run and the output produced matches the comments below each vehicle test

    public abstract class Vehicle : IVehicle

    {

        readonly string name;

        Cargo cargo;

        public Vehicle(string name)

        {

            this.name = name;

        }

​

        public string Name { get { return name; } }

        public Cargo LoadedCargo

        {

            get { return cargo; }

            set

            {

                if(value.Size > MaxCargoSize || value.Weight > MaxCargoWeight)

                {

                    value.ReportLoadingAttempt(false, this);

                    return;

                }

​

                cargo = value;

                cargo.ReportLoadingAttempt(true, this);

            }

        }

        public abstract int Wheels { get; }

        public abstract int Doors { get; }

        public abstract int Seats { get; }

        protected abstract int MaxCargoSize { get; }

        protected abstract int MaxCargoWeight { get; }

        public string Specs  { get { return Program.GetSpecsStringForVehicle(this); } }

    }

    public class Motorcycle : Vehicle

    {

        public Motorcycle(string name) : base (name) {}

        public override int Wheels { get { return 2; } }

        public override int Doors { get { return 0; } }

        public override int Seats { get { return 1; } }

        protected override int MaxCargoSize { get { return 10; } }

        protected override int MaxCargoWeight { get { return 10; } }

    }

    public class Car : Vehicle

    {

        const int NO_MORE_DOORS_THAN = 7;

        const int SEATS_NO_MORE_THAN = 10;

        const int CARGO_SIZE_NO_BIGGER_THAN = 100;

        const int CARGO_WEIGHT_NO_BIGGER_THAN = 100;

        readonly int doors;

        readonly int seats;

        readonly int maxCargoSize;

        readonly int maxCargoWeight;

        public Car(string name, int doors, int seats, int maxCargoSize, int maxCargoWeight) : base(name)

        {

            if(doors > NO_MORE_DOORS_THAN)

            {

                throw new Exception("Number of doors specified too much for any car");

            }

            if(seats > SEATS_NO_MORE_THAN)

            {

                throw new Exception("Number of seats specified too much for any car");

            }

            if(maxCargoSize > CARGO_SIZE_NO_BIGGER_THAN || maxCargoWeight > CARGO_WEIGHT_NO_BIGGER_THAN)

            {

                throw new Exception("Max cargo size or weight specified too big for any car");

            }

            this.doors = doors;

            this.seats = seats;

            this.maxCargoSize = maxCargoSize;

            this.maxCargoWeight = maxCargoWeight;

        }

        public override int Wheels { get { return 4; } }

        public override int Doors { get { return doors; } }

        public override int Seats { get { return seats; } }

        protected override int MaxCargoSize { get { return maxCargoSize; } }

        protected override int MaxCargoWeight { get { return maxCargoWeight; } }

    }

    public class Truck : Vehicle

    {

        readonly int wheels;

        public Truck(string name, int wheels) : base(name)

        {

            if(wheels < 4) throw new Exception("Trucks can't have less than 4 wheels");

            this.wheels = wheels;

        }

        public override int Wheels { get { return wheels; } }

        public override int Doors { get { return 2; } }

        public override int Seats { get { return 3; } }

        protected override int MaxCargoSize { get { return 1000; } }

        protected override int MaxCargoWeight { get { return 1000; } }

    }

    /*** DO NOT EDIT BELOW THIS LINE ***/

    public struct Cargo

    {

        public string Name { get; set;}

        public int Size { get; set;}

        public int Weight {get; set; }

        public void ReportLoadingAttempt(bool succeeded, IVehicle vehicle)

        {

            if(succeeded) Console.WriteLine(Name + " has been loaded onto " + vehicle.Name);

            else Console.WriteLine(Name + " NOT LOADED onto " + vehicle.Name);

        }

    }

    public interface IVehicle

    {

        string Name { get; }

        int Wheels { get; }

        int Doors { get; }

        int Seats { get; }

        string Specs { get; }

        Cargo LoadedCargo { get; set;}

    }

    public static string GetSpecsStringForVehicle(IVehicle vehicle)

    {

        return "This vehicle has " + vehicle.Wheels + " wheels, can seat " + vehicle.Seats + " " + (vehicle.Seats == 1 ? "person" : "people") + " and has " + vehicle.Doors + " doors";

    }

    static void TestVehicle(IVehicle vehicleToTest, Cargo[] cargos)

    {

        //Specify which vehicle we are testing

        Console.WriteLine(vehicleToTest.Name + ":");

        //Write out the specs for this car

        Console.WriteLine(vehicleToTest.Specs);

        foreach(Cargo cargoToTryLoading in cargos)

        {

            vehicleToTest.LoadedCargo = cargoToTryLoading;

        }

        Console.WriteLine("FINAL CARGO for " + vehicleToTest.Name + ": " + vehicleToTest.LoadedCargo.Name);

        Console.WriteLine("");

    }

    public static void Main()

    {

        //Cargo list to test

        Cargo[] cargos = new Cargo[]

        {

            new Cargo() { Name = "Backpack", Size = 5, Weight = 5 },

            new Cargo() { Name = "Bike", Size = 20, Weight = 25 },

            new Cargo() { Name = "Camping gear", Size = 45, Weight = 35 },

            new Cargo() { Name = "Shopping centre delivery", Size = 120, Weight = 150 }

        };

        Motorcycle motorbike = new Motorcycle("Motorbike");

        TestVehicle(motorbike, cargos);

        /* TEST RESULTS SHOULD BE AS FOLLOWING:

        Motorbike:

        This vehicle has 2 wheels, can seat 1 person and has 0 doors

        Backpack has been loaded onto Motorbike

        Bike NOT LOADED onto Motorbike

        Camping gear NOT LOADED onto Motorbike

        Shopping centre delivery NOT LOADED onto Motorbike

        FINAL CARGO for Motorbike: Backpack*/

​

        Car smallCar = new Car("Small car", 2, 2, 20, 20);

        TestVehicle(smallCar, cargos);

        /* TEST RESULTS SHOULD BE AS FOLLOWING:

        Small car:

        This vehicle has 4 wheels, can seat 2 people and has 2 doors

        Backpack has been loaded onto Small car

        Bike NOT LOADED onto Small car

        Camping gear NOT LOADED onto Small car

        Shopping centre delivery NOT LOADED onto Small car

        FINAL CARGO for Small car: Backpack*/

        Car averageCar = new Car("Average car", 4, 5, 50, 30);

        TestVehicle(averageCar, cargos);

        /* TEST RESULTS SHOULD BE AS FOLLOWING:

        Average car:

        This vehicle has 4 wheels, can seat 5 people and has 4 doors

        Backpack has been loaded onto Average car

        Bike has been loaded onto Average car

        Camping gear NOT LOADED onto Average car

        Shopping centre delivery NOT LOADED onto Average car

        FINAL CARGO for Average car: Bike*/

        Car peopleCarrier = new Car("People carrier", 4, 8, 60, 40);

        TestVehicle(peopleCarrier, cargos);

        /* TEST RESULTS SHOULD BE AS FOLLOWING:

        People carrier:

        This vehicle has 4 wheels, can seat 8 people and has 4 doors

        Backpack has been loaded onto People carrier

        Bike has been loaded onto People carrier

        Camping gear has been loaded onto People carrier

        Shopping centre delivery NOT LOADED onto People carrier

        FINAL CARGO for People carrier: Camping gear*/

        Truck eightWheeler = new Truck("8 wheeler truck", 8);

        TestVehicle(eightWheeler, cargos);

        /* TEST RESULTS SHOULD BE AS FOLLOWING:

        8 wheeler truck:

        This vehicle has 8 wheels, can seat 3 people and has 2 doors

        Backpack has been loaded onto 8 wheeler truck

        Bike has been loaded onto 8 wheeler truck

        Camping gear has been loaded onto 8 wheeler truck

        Shopping centre delivery has been loaded onto 8 wheeler truck

        FINAL CARGO for 8 wheeler truck: Shopping centre delivery*/

        try 

        {

            Truck twoWheelTruck = new Truck("2 wheeler truck", 2);

        }

        catch(Exception ex)

        {

            Console.WriteLine(ex.Message);

        }

        /* TEST RESULTS SHOULD BE AS FOLLOWING:

        Trucks can't have less than 4 wheels*/

        try 

        {

            Car twelveSeatCar = new Car("Minibus!", 4, 12, 80, 80);

        }

        catch(Exception ex)

        {

            Console.WriteLine(ex.Message);

        }

        /* TEST RESULTS SHOULD BE AS FOLLOWING:

        Number of seats specified too much for any car*/

    }

}