fms.rao

import java.awt.Point
import java.util.List

constant ROBOT_RETURN_DURATION = 0.2

sequence exponential = new Exponential(123456789)
sequence truckLoadingDuration = new Exponential(123456789, 1 / 1.5)
sequence truckTransferDuration = new Exponential(123456789, 1 / 2.0)
sequence installingOnMachineDuration = new Exponential(123456789, 1 / 1.0)
sequence machineUnloadingDuration = new Exponential(123456789, 1 / 0.5)

enum Position {
	MACHINE_1, MACHINE_2, MACHINE_3, STORAGE_1, STORAGE_2, TRUCK_1_FROM, TRUCK_1_TO, TRUCK_2_FROM, TRUCK_2_TO, NOWHERE
}

enum TruckState {FREE, BUSY, LOADED, MOVING, ARRIVED, WAITING}
type Trucks {
	Position position
	TruckState state
}
resource truck1 = Trucks.create(Position.TRUCK_1_FROM, TruckState.FREE)
resource truck2 = Trucks.create(Position.TRUCK_2_FROM, TruckState.FREE)

enum RobotState {FREE, BUSY}
type Robots {
	Position position
	RobotState state
	ViewRobotInfo viewRobotInfo
}
type ViewRobotInfo {
	Point basePoint
	List<Position> positions
	List<Integer> angles
}
resource robot1 = Robots.create(
	Position.STORAGE_1,
	RobotState.FREE,
	ViewRobotInfo.create(new Point(100, 150), newArrayList(Position.NOWHERE, Position.STORAGE_1
	, Position.TRUCK_1_FROM), newArrayList(0, -60, 32))
)
resource robot2 = Robots.create(
	Position.TRUCK_1_TO,
	RobotState.FREE,
	ViewRobotInfo.create(new Point(550, 195),
		newArrayList(Position.NOWHERE, Position.MACHINE_1, Position.TRUCK_1_TO, Position.MACHINE_2,
			Position.TRUCK_2_FROM), newArrayList(95, -5, 180, 50, 115))
)
resource robot3 = Robots.create(
	Position.TRUCK_2_TO,
	RobotState.FREE,
	ViewRobotInfo.create(new Point(428, 460),
		newArrayList(Position.NOWHERE, Position.MACHINE_3, Position.TRUCK_2_TO, Position.STORAGE_2),
		newArrayList(180, 225, 0, 135))
)

enum MachineState {FREE, LOADING, READY_FOR_MACHINING, MACHINING, UNLOADING, FINISHED_MACHINING}
type Machines {
	Position position
	MachineState state
	double machiningDuration
}
resource machine1 = Machines.create(Position.MACHINE_1, MachineState.FREE, 28)
resource machine2 = Machines.create(Position.MACHINE_2, MachineState.FREE, 28)
resource machine3 = Machines.create(Position.MACHINE_3, MachineState.FREE, 15)

type Details {
	Position position
}

def init() {
	for(var i = 0; i < 10; i += 1) {
		Details.create(Position.STORAGE_1)
	}
}

def terminateCondition() {
	return Details.accessible.filter[position == Position.STORAGE_2].size() == Details.all.size()
}

operation LoadingDetail() {
	relevant detail = Details.accessible.filter[position == Position.STORAGE_1].any
	relevant robot = Robots.accessible.filter[
		position == Position.STORAGE_1 && state == RobotState.FREE
	].any
	relevant truck = Trucks.accessible.filter[
		position == Position.TRUCK_1_FROM && state == TruckState.FREE
	].any

	def begin() {
		robot.state = RobotState.BUSY
		truck.state = TruckState.BUSY

		robot.position = Position.NOWHERE
		detail.position = robot.position
	}

	def duration() {
		return truckLoadingDuration.next()
	}

	def end() {
		robot.state = RobotState.FREE
		truck.state = TruckState.LOADED

		robot.position = Position.TRUCK_1_FROM
		detail.position = robot.position
	}
}

operation TransferingDetail() {
	relevants truck, detail = combination(
		Trucks.accessible.filter[state == TruckState.LOADED],
		Details.accessible
	).filter[truck.position == detail.position].any of types Trucks, Details

	def begin() {
		truck.state = TruckState.MOVING
		detail.position = Position.NOWHERE
	}

	def duration() {
		return truckTransferDuration.next()
	}

	def end() {
		truck.state = TruckState.ARRIVED

		truck.position = whereTruckMove(truck.position)
		detail.position = truck.position
	}
}

Position whereTruckMove(Position position){
	switch (position) {
		case TRUCK_1_FROM: return Position.TRUCK_1_TO
		case TRUCK_2_FROM: return Position.TRUCK_2_TO
		case TRUCK_1_TO: return Position.TRUCK_1_FROM
		case TRUCK_2_TO: return Position.TRUCK_2_FROM
		default: throw new IllegalArgumentException("Unexpected truck position.")
	}
}

operation InstallingOnMachine() {
	relevants machine, truck, robot, detail = combination(
		Machines.accessible.filter[state == MachineState.FREE],
		Trucks.accessible.filter[state == TruckState.ARRIVED],
		Robots.accessible.filter[state == RobotState.FREE],
		Details.accessible
	).filter[
		truck.position == robot.position && truck.position == detail.position 
		&& isRobotConnectedWithMachine(robot.position, machine.position)
	].any of types Machines, Trucks, Robots, Details

	def begin() {
		machine.state = MachineState.LOADING
		truck.state = TruckState.WAITING
		robot.state = RobotState.BUSY
		robot.position = Position.NOWHERE
	}

	def duration() {
		return installingOnMachineDuration.next()
	}

	def end() {
		machine.state = MachineState.READY_FOR_MACHINING
		truck.state = TruckState.FREE
		robot.state = RobotState.FREE

		robot.position = machine.position
		detail.position = machine.position
	}
}

operation Machining() {
	relevants machine, detail = combination(
		Machines.accessible.filter[state == MachineState.READY_FOR_MACHINING],
		Details.accessible
	).filter[detail.position == machine.position].any of types Machines, Details

	def begin() {
		machine.state = MachineState.MACHINING
	}

	def duration() {
		return machine.machiningDuration
	}

	def end() {
		machine.state = MachineState.FINISHED_MACHINING
	}
}

operation FinishingMachiningOnMachine1Or2() {
	relevant truck = Trucks.accessible.filter[
		state == TruckState.FREE && position == Position.TRUCK_2_FROM
	].any

	relevants machine, detail, robot = combination(
		Machines.accessible.filter[state == MachineState.FINISHED_MACHINING 
			&& (position == Position.MACHINE_1 || position == Position.MACHINE_2)
		],
		Details.accessible,
		Robots.accessible.filter[state == RobotState.FREE]
	).filter[
		machine.position == detail.position && isRobotConnectedWithMachine(robot.position, machine.position)
	].any of types Machines, Details, Robots

	def begin() {
		machine.state = MachineState.UNLOADING
		robot.state = RobotState.BUSY
		robot.position = Position.NOWHERE
		truck.state = TruckState.BUSY
		detail.position = Position.NOWHERE
	}

	def duration() {
		return machineUnloadingDuration.next()
	}

	def end() {
		machine.state = MachineState.FREE
		robot.state = RobotState.FREE
		truck.state = TruckState.LOADED

		robot.position = Position.TRUCK_2_FROM
		detail.position = robot.position
	}
}

boolean isRobotConnectedWithMachine(Position robotPosition, Position machinePosition)
{
	if (robotPosition == Position.MACHINE_1 || robotPosition == Position.MACHINE_2 
		|| robotPosition == Position.TRUCK_1_TO || robotPosition == Position.TRUCK_2_FROM) {
		return machinePosition == Position.MACHINE_1 || machinePosition == Position.MACHINE_2
	} else if (robotPosition == Position.MACHINE_3 || robotPosition == Position.TRUCK_2_TO 
		|| robotPosition == Position.STORAGE_2) {
		return machinePosition == Position.MACHINE_3
	}

	return false
}

operation FinishingMachiningOnMachine3() {
	relevant machine = Machines.accessible.filter[
		state == MachineState.FINISHED_MACHINING && position == Position.MACHINE_3
	].any
	relevant detail = Details.accessible.filter[position == Position.MACHINE_3].any
	relevant robot = Robots.accessible.filter[
		state == RobotState.FREE && isRobotConnectedWithMachine(position, machine.position)
	].any

	def begin() {
		machine.state = MachineState.UNLOADING
		detail.position = Position.NOWHERE
		robot.state = RobotState.BUSY
		robot.position = Position.NOWHERE
	}

	def duration() {
		return machineUnloadingDuration.next()
	}

	def end() {
		robot.state = RobotState.FREE
		robot.position = Position.STORAGE_2
		machine.state = MachineState.FREE
		detail.position = Position.STORAGE_2
	}
}

operation RobotReturn() {
	relevant robot = Robots.accessible.filter[
		position != getRobotReturnPosition(it) && state == RobotState.FREE
	].any

	def begin() {
		robot.state = RobotState.BUSY
		robot.position = Position.NOWHERE
	}

	def duration() {
		return ROBOT_RETURN_DURATION
	}

	def end() {
		robot.state = RobotState.FREE
		robot.position = getRobotReturnPosition(robot)
	}
}

Position getRobotReturnPosition(Robots robot) {
	switch (robot) {
		case robot1: return Position.STORAGE_1
		case robot2: return Position.TRUCK_1_TO
		case robot3: return Position.TRUCK_2_TO
	}
}

operation TruckReturn() {
	relevant truck = Trucks.accessible.filter[
		state == TruckState.FREE && isTruckInToPosition(position)
	].any

	def begin() {
		truck.state = TruckState.BUSY
	}

	def duration () {
		return truckTransferDuration.next()
	}

	def end() {
		truck.state = TruckState.FREE
		truck.position = whereTruckMove(truck.position)
	}
}

boolean isTruckInToPosition(Position position){
	if (position == Position.TRUCK_1_TO || position == Position.TRUCK_2_TO)
		return true
	else
		return false;
}

logic Model {
	activity loadingDetail = new Activity(LoadingDetail.create())
	activity transferingDetail = new Activity(TransferingDetail.create())
	activity installingOnMachine = new Activity(InstallingOnMachine.create())
	activity machining = new Activity(Machining.create())
	activity finishingMachiningOnMachine1Or2 = new Activity(FinishingMachiningOnMachine1Or2.create())
	activity finishingMachiningOnMachine3 = new Activity(FinishingMachiningOnMachine3.create())
	activity robotReturn = new Activity(RobotReturn.create())
	activity truckReturn = new Activity(TruckReturn.create())
}

frame Frame {
	def init() {
		background = new Background(800, 600, RaoColor.WHITE)
	}
	def draw() {
		val yOffset = 15;

		drawText('Time:', 10, 5)
		drawText(currentTime, 60, 5)
		drawText('STATE', 350, 45)
		drawText('POSITION', 600, 45)

		for (machine : Machines.all) {
			drawText('machine ' + (machine.number + 1), 10, 70 + machine.number * yOffset);
			drawText(machine.state, 350, 70 + machine.number * yOffset);
			drawText(machine.position, 600, 70 + machine.number * yOffset);
		}

		for (truck : Trucks.all) {
			drawText('truck ' + (truck.number + 1), 10, 125 + truck.number * yOffset)
			drawText(truck.state, 350, 125 + truck.number * yOffset)
			drawText(truck.position, 600, 125 + truck.number * yOffset)
		}

		for (robot : Robots.all) {
			drawText('robot ' + (robot.number + 1), 10, 165 + robot.number * yOffset)
			drawText(robot.state, 350, 165 + robot.number * yOffset)
			drawText(robot.position, 600, 165 + robot.number * yOffset)
		}

		drawText('POSITION', 350, 250)
		for (detail : Details.all) {
			drawText('detail ' + (detail.number + 1), 10, 270 + detail.number * yOffset)
			drawText(detail.position, 350, 270 + detail.number * yOffset)
		}

		drawText('Detail`s count in storage 1', 10, 440)
		drawText(Details.accessible.filter[position == Position.STORAGE_1].size(), 350, 440)
		drawText('Detail`s count in storage 2', 10, 460)
		drawText(Details.accessible.filter[position == Position.STORAGE_2].size(), 350, 460)
	}
}

Point getRotatedPoint(Point basePoint,Point point,int angle){
	val angleInRad = angle * Math.PI / 180
	val rotatePoint = new Point(
		((point.x - basePoint.x) * Math.cos(angleInRad) -
			(point.y - basePoint.y) * Math.sin(angleInRad)).intValue(),
		((point.x - basePoint.x) * Math.sin(angleInRad) +
			(point.y - basePoint.y) * Math.cos(angleInRad)).intValue())
	rotatePoint.x += basePoint.x
	rotatePoint.y += basePoint.y

	return rotatePoint
}

frame ModelAnimation {

	def init() {
		background = new Background(800, 600, RaoColor.WHITE)
	}

	def draw() {
		// Транспортные линии
		drawLine(130, 180, 130, 210, RaoColor.BLACK)
		drawLine(130, (180 + 210) / 2, 500, (180 + 210) / 2, RaoColor.BLACK)
		drawLine(500, 180, 500, 210, RaoColor.BLACK)
		drawLine(500, 230, 530, 230, RaoColor.BLACK)
		drawLine((500 + 530) / 2, 230, (500 + 530) / 2, 500, RaoColor.BLACK)
		drawLine(500, 500, 530, 500, RaoColor.BLACK)

		// Транспорт
		if (truck1.state == TruckState.MOVING)
			drawRectangle(285, 180, 60, 30, RaoColor.DARK_GRAY, RaoColor.DARK_GRAY)
		else if (truck1.position == Position.TRUCK_1_TO)
			drawRectangle(430, 180, 60, 30, RaoColor.DARK_GRAY, RaoColor.DARK_GRAY)
		else
			drawRectangle(140, 180, 60, 30, RaoColor.DARK_GRAY, RaoColor.DARK_GRAY)

		if (truck2.state == TruckState.MOVING)
			drawRectangle(500, 330, 30, 60, RaoColor.DARK_GRAY, RaoColor.DARK_GRAY)
		else if (truck2.position == Position.TRUCK_2_TO)
			drawRectangle(500, 430, 30, 60, RaoColor.DARK_GRAY, RaoColor.DARK_GRAY)
		else
			drawRectangle(500, 240, 30, 60, RaoColor.DARK_GRAY, RaoColor.DARK_GRAY)

		val machinesCoordinates = newArrayList(
			newArrayList(610, 160),
			newArrayList(580, 240),
			newArrayList(270, 370)
		)
		for (machine : Machines.all) {
			drawText('Machine ' + (machine.number + 1), machinesCoordinates.get(machine.number).get(0),
				machinesCoordinates.get(machine.number).get(1) - 20, RaoColor.BLACK, 130, Alignment.CENTER
			)
			val machineColor = if (machine.state == MachineState.MACHINING) RaoColor.DARK_GREEN else RaoColor.DARK_RED
			drawRectangle(machinesCoordinates.get(machine.number).get(0), machinesCoordinates.get(machine.number).get(1),
				130, 50, machineColor, machineColor
			)
		}

		drawText("Storage 1", 100, 20, RaoColor.BLACK, 130, Alignment.CENTER);
		drawRectangle(100, 40, 130, 50, RaoColor.GRAY, RaoColor.GRAY)
		drawText("Details: " + Details.accessible.filter[position == Position.STORAGE_1].size(), 100, 45,
			RaoColor.BLACK, 130, Alignment.CENTER);

		drawText("Storage 2", 270, 480, RaoColor.BLACK, 130, Alignment.CENTER);
		drawRectangle(270, 500, 130, 50, RaoColor.GRAY, RaoColor.GRAY)
		drawText("Details: " + Details.accessible.filter[position == Position.STORAGE_2].size(), 270, 530,
			RaoColor.BLACK, 130, Alignment.CENTER);

		for (robot : Robots.all) {
			var baseRobotPoint = robot.viewRobotInfo.basePoint

			var baseRobotCircle1Point = new Point(baseRobotPoint.x, baseRobotPoint.y)
			var baseRobotLine1Point1 = new Point(baseRobotPoint.x - 30, baseRobotPoint.y)
			var baseRobotLine1Point2 = new Point(baseRobotPoint.x + 80, baseRobotPoint.y)
			var baseRobotCircle2Point = new Point(baseRobotPoint.x + 80, baseRobotPoint.y)
			var baseRobotTrianglePoint1 = new Point(baseRobotPoint.x + 85, baseRobotPoint.y + 10)
			var baseRobotTrianglePoint2 = new Point(baseRobotPoint.x + 85, baseRobotPoint.y - 10)
			var baseRobotTrianglePoint3 = new Point(baseRobotPoint.x + 95, baseRobotPoint.y)

			var angle = robot.viewRobotInfo.angles.get(robot.viewRobotInfo.positions.indexOf(robot.position))

			var rotateRobotCircle1Point = getRotatedPoint(baseRobotPoint, baseRobotCircle1Point, angle)
			var rotateRobotLine1Point1 = getRotatedPoint(baseRobotPoint, baseRobotLine1Point1, angle)
			var rotateRobotLine1Point2 = getRotatedPoint(baseRobotPoint, baseRobotLine1Point2, angle)
			var rotateRobotCircle2Point = getRotatedPoint(baseRobotPoint, baseRobotCircle2Point, angle)
			var rotateRobotTrianglePoint1 = getRotatedPoint(baseRobotPoint, baseRobotTrianglePoint1, angle)
			var rotateRobotTrianglePoint2 = getRotatedPoint(baseRobotPoint, baseRobotTrianglePoint2, angle)
			var rotateRobotTrianglePoint3 = getRotatedPoint(baseRobotPoint, baseRobotTrianglePoint3, angle)

			drawCircle(rotateRobotCircle1Point.x, rotateRobotCircle1Point.y, 20, RaoColor.RED, RaoColor.DARK_RED)
			drawLine(rotateRobotLine1Point1.x, rotateRobotLine1Point1.y, rotateRobotLine1Point2.x,
				rotateRobotLine1Point2.y, RaoColor.RED
			)
			drawCircle(rotateRobotCircle2Point.x, rotateRobotCircle2Point.y, 10, RaoColor.RED, RaoColor.DARK_RED)
			drawTriangle(
				rotateRobotTrianglePoint1.x,
				rotateRobotTrianglePoint1.y,
				rotateRobotTrianglePoint2.x,
				rotateRobotTrianglePoint2.y,
				rotateRobotTrianglePoint3.x,
				rotateRobotTrianglePoint3.y,
				RaoColor.RED,
				RaoColor.DARK_RED
			)
		}
	}
}