Serious slowdown in the resolution of the planning.

[antoniojbm]

Good morning, in the end I have decided to use temporary planning, everything is going well I have achieved all the goals that I have set but I have a problem, sometimes when I add some changes the planning goes from taking 5 seconds to take more than 10 minutes, and even hours, and I do not understand the reason why this is happening to me.

import os
import tkinter as tk
from tkinter import ttk
from tkinter import filedialog as fd
from tkinter.messagebox import showinfo
import csv
import unified_planning
from unified_planning.shortcuts import *
from unified_planning.plans import SequentialPlan, ActionInstance
from datetime import datetime
import time
from unified_planning.plot import (
    plot_plan,  # plot_plan plots all the types of plans, but is not customizable, while specific methods
    plot_sequential_plan,
    plot_time_triggered_plan,
    plot_partial_order_plan,
    plot_contingent_plan,
    plot_stn_plan,
    plot_causal_graph,
)


# 1.- Optimizar la planificación.

# 2.- Establecer prioridades a la hora de tratar a los Vessels (puede quedar resuelto al optimizar)

# 3.- Empezar la planificación con gabarras ocupadas en otras tareas (se podría resolver si funciona el “At 10 ….” en initials).

# 4.- Que haya gabarras que estén ocupadas en otras tareas o inactivas en mitad de la planificación durante un tiempo (se podría resolver si funciona el “At 10 ….” en initials).



# 6.- Que a la gabarra que se le ha acabado el combustible, haga refueling y siga prestando servicios.

# 7.- Gabarras a zona de espera en fondeadero.

# 8.- Depurar código.

# 10.- Salida de datos.

# 11.- Ejecutar escenario de la demo. 

        
#Clase Data
class Data:
    def __init__(self ,iD, start_time, deltaAnch_Capacity):
        self.iD = iD
        self.start_time = start_time
        self.deltaAnch_Capacity = int(deltaAnch_Capacity)      


#Class Action
class Action:
    def __init__(self ,name, start_time, end_time, duration, origin, destine):
        self.name = name
        self.start_time = start_time
        self.end_time = end_time
        self.duration = duration
        self.origin = origin
        self.destine = destine

# Clase Vessel
class Vessel:

    def __init__(self, id, name, bunkeringProvider, bunkeringTime,
                  timeToAnchorage, timeFromAnchorage,
                 timeToWaitingPoint, timeFromWaitingPoint, startAtAnchorage,
                 timeStartAtAnchorage, fuelRequested,fuelActuallyDelivered, etaAnch,
                 ataPBP, ataBerth, waitingTime, atsBunk, atcBunk, atdBerth, atdPBP,
                 *args,**kargs):
        
        self.id = id
        self.name = name
        self.bunkeringProvider = bunkeringProvider
        self.bunkeringTime = int(bunkeringTime)
        self.timeToAnchorage = int(timeToAnchorage)
        self.timeFromAnchorage = int(timeFromAnchorage)
        self.timeToWaitingPoint = int(timeToWaitingPoint)
        self.timeFromWaitingPoint = int(timeFromWaitingPoint)
        self.startAtAnchorage = startAtAnchorage
        self.timeStartAtAnchorage = int(timeStartAtAnchorage)
        self.fuelRequested = int(fuelRequested)
        self.actions = []
        self.priority = 0
        
        self.fuelActuallyDelivered = fuelActuallyDelivered
        self.etaAnch = etaAnch
        self.ataPBP = ataPBP
        self.ataBerth = ataBerth
        self.waitingTime = waitingTime
        self.atsBunk = atsBunk
        self.atcBunk = atcBunk
        self.atdBerth = atdBerth
        self.atdPBP = atdPBP
        
#Clase Gabarra
class Barge:
    def __init__(self, id,name, companyLegalCode, refuelingPoint,
                 baseStations,timeToRefueling,
                 fuelAvailable, locationStartID):
        self.id = id
        self.name = name
        self.companyLegalCode = companyLegalCode
        self.refuelingPoint = refuelingPoint
        self.baseStations = baseStations
        self.timeToRefueling = timeToRefueling
        self.fuelCapacity = fuelAvailable
        self.fuelAvailable = fuelAvailable
        self.locationStartID = locationStartID
        self.actions = []
        
        #Clase Inactividad Gabarras 
class BargeInactivityPeriod:
    def __init__(self ,inact_ID, bargeName, inact_timeStart, inact_Duration,
                 inact_BargeEndLocation):
        self.inact_ID = inact_ID
        self.bargeName = bargeName
        self.inact_timeStart = inact_timeStart
        self.inact_Duration = inact_Duration
        self.inact_BargeEndLocation = inact_BargeEndLocation
        
        
        
        #Clase Location Gabarras 
class BargeLocation:
    def __init__(self ,location_ID, location_name, location_coord,location_type, location_capacity,
                 location_timeToAnch, used):
        self.location_ID = location_ID
        self.location_name = location_name
        self.location_coord = location_coord
        self.location_type = location_type
        self.location_capacity = location_capacity
        self.location_timeToAnch = location_timeToAnch
        self.used = used


        #Clase Time_between_locations
class Time_between_locations:
    def __init__(self ,time_ID, time_name, time_betwen_locs):
        self.time_ID = time_ID
        self.time_name = time_name
        self.time_betwen_locs = time_betwen_locs

        
        
        
        #Clase Barges_actual_events 
class Barges_actual_events:
    def __init__(self ,iD, name, typeB, initTime, endTime, origin, destination, duration):
        self.iD = iD
        self.name = name
        self.type = typeB
        self.initTime = initTime
        self.endTime = endTime
        self.origin = origin
        self.destination = destination
        self.duration = duration
    
       

listVessels = []
listBarges = []
listBargesLocations = []
listBargesInactivityPeriod = []
listData = []
listTime_betwen_locs = []
listBargesActualEvents = []



# # create interface
# root = tk.Tk()
# root.title('Bunkering')
# root.resizable(False, False)
# root.geometry('400x400')

directory = fd.askdirectory()

# ask file Data
filenameData = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameData = f'{directory}/General.csv'



# ask file Vessels
filenameVessel = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameVessel =  f'{directory}/Vessels.csv'


# ask file barges
filenameBarge = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameBarge =  f'{directory}/Barges.csv'


# ask file barges inactivity Period
filenameBargeInactivityPeriod = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameBargeInactivityPeriod =  f'{directory}/Barges_inactivity_periods.csv'


# ask file barges location
filenameBargeLocation = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameBargeLocation =  f'{directory}/Locations.csv'


# ask file Time_between_locations
filenameTime_between_locations = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameTime_between_locations =  f'{directory}/Time_between_locations.csv'


# ask file Barges_actual_events
filenameBarges_actual_events = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameBarges_actual_events =  f'{directory}/Barges_actual_events.csv'


# Read Csv


    #Leer Archivo de Data
with open(filenameData) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    auxCount = 1
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'Start_Time' == column:
                    posDStart_Time = column_count
                elif 'Anchorage_capacity' == column:
                    posDDeltaAnch_capacity = column_count

                column_count += 1
        elif line_count!=0:
            listData.append(Data(auxCount, row[posDStart_Time], row[posDDeltaAnch_capacity]))
            auxCount = auxCount + 1
        line_count += 1
    
    



    #Leer Archivo de Vessel
with open(filenameVessel) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    auxCount = 1
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'Vessel_name' == column:
                    posVName = column_count
                elif 'Vessel_bunkeringProvider' == column:
                    posVBunkProvider = column_count
                elif 'Bunkering_time' == column:
                    posVBunkeringTime = column_count
                elif 'Vessel_timeToAnchorage' == column:
                    posVTimeToAnch = column_count
                elif 'Vessel_timeFromAnchorage' == column:
                    posVTimeFromAnch = column_count
                elif 'Vessel_timeToWaitingPoint' == column:
                    posVTimeToWP = column_count
                elif 'Vessel_timeFromWaitingPoint' == column:
                    posVTimeFromWP = column_count
                elif 'Vessel_startAtAnchorage' == column:
                    posVStartAtAnch = column_count
                elif 'Vessel_timeStartAtAnchorage' == column:
                    posVTimeStartAtAnch = column_count
                elif 'Vessel_fuelRequested' == column:
                    posVFuelRequested = column_count
                    
                elif 'Vessel_fuelActuallyDelivered' == column:
                    posVFuelAct = column_count
                elif 'Vessel_ETA_Anchorage' == column:
                    posVEtaAnch = column_count
                elif 'Vessel_ATA_PBP' == column:
                    posVATAPBP = column_count
                elif 'Vessel_ATA_Berth' == column:
                    posVATABerth = column_count
                elif 'Vessel_waitingTime' == column:
                    posVWaitingTime = column_count
                elif 'Vessel_ATS_Bunkering' == column:
                    posVATSBunk = column_count
                elif 'Vessel_ATC_Bunkering' == column:
                    posVATCBunk = column_count
                elif 'Vessel_ATD_Berth' == column:
                    posVATDBerth = column_count
                elif 'Vessel_ATD_PBP' == column:
                    posVATDPBP = column_count
                    
                column_count += 1
        elif line_count!=0:
            listVessels.append(Vessel(auxCount, row[posVName], row[posVBunkProvider], row[posVBunkeringTime],
                                          row[posVTimeToAnch], row[posVTimeFromAnch], row[posVTimeToWP], row[posVTimeFromWP],
                                        row[posVStartAtAnch], row[posVTimeStartAtAnch], row[posVFuelRequested],
                                        row[posVFuelAct], row[posVEtaAnch], row[posVATAPBP],
                                        row[posVATABerth], row[posVWaitingTime], row[posVATSBunk],
                                        row[posVATCBunk],row[posVATDBerth], row[posVATDPBP]))
            auxCount = auxCount + 1
        line_count += 1
        
        
        
    #Leer Archivo de BargeInactivityPeriod
with open(filenameBargeInactivityPeriod) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    auxCount = 1
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'BargeInact_name' == column:
                    posIBargeID = column_count
                elif 'BargeInact_timeStart' == column:
                    posITimeStart = column_count
                elif 'BargeInact_duration' == column:
                    posIDuration = column_count
                elif 'BargeInact_endLocation' == column:
                    posIBargeEndLocation = column_count                 

                column_count += 1
                
        elif line_count!=0:
            listBargesInactivityPeriod.append(BargeInactivityPeriod(auxCount, row[posIBargeID], row[posITimeStart], 
                                         row[posIDuration], row[posIBargeEndLocation]))
            auxCount = auxCount + 1
        line_count += 1
        
        
# Barge Location
with open(filenameBargeLocation) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'Location_id' == column:
                    posLID = column_count
                elif 'Location_name' == column:
                    posLName = column_count
                elif 'BargeLocation_Coordinates' == column:
                    posLCoord = column_count
                elif 'Location_type' == column:
                    posLType = column_count
                elif 'Location_capacity' == column:
                    posLCapacity = column_count
                elif 'Location_timeToAnchorage' == column:
                    posLTimeToAnch = column_count                 

                column_count += 1
                
        elif line_count!=0:
            listBargesLocations.append(BargeLocation(row[posLID], row[posLName], row[posLCoord], 
                                        row[posLType], row[posLCapacity], row[posLTimeToAnch], False))
        line_count += 1
            

        
    #Leer Archivo de Barge
with open(filenameBarge) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    auxCount = 1
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'Barge_name' == column:
                    posBName = column_count
                elif 'Barge_companyLegalCode' == column:
                    posBCompanyLegalCode = column_count
                elif 'Barge_refuelingPoint' == column:
                    posBRefuelPoint = column_count
                elif 'Barge_baseStations' == column:
                    posBBaseStation = column_count
                elif 'Barge_timeToRefueling' == column:
                    posBTimeToRefuel = column_count
                elif 'Barge_fuelAvailable' == column:
                    posBFuelAvailable = column_count
                elif 'Barge_locationStartId' == column:
                    posBLocationStartID = column_count

                column_count += 1
        elif line_count!=0:
            listBarges.append(Barge(auxCount, row[posBName], row[posBCompanyLegalCode], row[posBRefuelPoint], row[posBBaseStation],
                                          row[posBTimeToRefuel], row[posBFuelAvailable], row[posBLocationStartID]))
            auxCount = auxCount + 1

        line_count += 1



# Time_between_locations
with open(filenameTime_between_locations) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    auxColumn = []
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'Locations' == column:
                    posTime_ID = column_count
                elif 'Location_name' == column:
                    posTime_name = column_count
                else:
                    auxColumn.append(column)
            
                column_count += 1
                
        elif line_count!=0:
            auxInt = 0
            auxTBL = {}
            for i in auxColumn:
                auxTBL.update({i : row[2 + auxInt]})
                auxInt = auxInt + 1
                    
            listTime_betwen_locs.append(Time_between_locations(row[posTime_ID], row[posTime_name],
                                         auxTBL))
        line_count += 1
            


# Barge Location
with open(filenameBarges_actual_events) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    countID = 0
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'BargeActualEvent_name' == column:
                    posBarges_actual_events_name = column_count
                elif 'BargeActualEvent_type' == column:
                    posBarges_actual_events_type  = column_count
                elif 'BargeActualEvent_InitTime' == column:
                    posBarges_actual_events_initTime = column_count
                elif 'BargeActualEvent_endTime' == column:
                    posBarges_actual_events_endTime = column_count    
                elif 'BargeActualEvent_origin' == column:
                    posBarges_actual_events_origin = column_count    
                elif 'BargeActualEvent_destination' == column:
                    posBarges_actual_events_destination = column_count    
                elif 'BargeActualEvent_duration' == column:
                    posBarges_actual_events_duration = column_count                 

                column_count += 1
                
        elif line_count!=0:
            listBargesActualEvents.append(Barges_actual_events(countID, row[posBarges_actual_events_name], row[posBarges_actual_events_type], 
                                         row[posBarges_actual_events_initTime], row[posBarges_actual_events_endTime], row[posBarges_actual_events_origin],
                                          row[posBarges_actual_events_destination], row[posBarges_actual_events_duration]))
            countID = countID + 1
        line_count += 1
            



# PRIORIDAD
def myFunc(e):
  return e.timeToAnchorage

count = 1
listVessels.sort(key=myFunc)
for vessel in listVessels:
    if vessel.startAtAnchorage == "False":
        
        vessel.priority = count
        print (f"{vessel.name} - {vessel.timeToAnchorage} - {vessel.priority}")
        count=count+1





# -------------------------------------------------------------------



# Variables PPDL

Vessel = UserType('Vessel')
Barge = UserType('Barge')
Position = UserType('Position')




# Define Fluents
vessel_on = unified_planning.model.Fluent('vessel-on', BoolType(), v=Vessel, p=Position)
barge_on = unified_planning.model.Fluent('barge-on', BoolType(), b=Barge, p=Position)
isFueled = unified_planning.model.Fluent('isFueled', BoolType(), v=Vessel)
nextPosition = unified_planning.model.Fluent('nextPosition', BoolType(), p0=Position, p1=Position)
isAnchorage = unified_planning.model.Fluent('isAnchorage', BoolType(), p=Position)
bargeInUse = unified_planning.model.Fluent('bargeInUse', BoolType(), b=Barge)
positionFree = unified_planning.model.Fluent('positionFree', BoolType(), p=Position)
vesselBargePosition = unified_planning.model.Fluent('vesselBargePosition', BoolType(), v=Vessel, b=Barge, p=Position)
vesselBarge = unified_planning.model.Fluent('vesselBarge', BoolType(), v=Vessel, b=Barge)
timeInitToAnch = unified_planning.model.Fluent('timeInitToAnch', IntType(), v=Vessel)
timeInitToWait = unified_planning.model.Fluent('timeInitToWait', IntType(), v=Vessel)
timeWaitToAnch = unified_planning.model.Fluent('timeWaitToAnch', IntType(), v=Vessel)
timeAnchToExit = unified_planning.model.Fluent('timeAnchToExit', IntType(), v=Vessel)
timeBunkering = unified_planning.model.Fluent('timeBunkering', IntType(),  v=Vessel)
timeBargeLocationToAnchor  = unified_planning.model.Fluent('timeBargeLocationToAnchor', IntType(), p=Position)


numberOfVessels  = unified_planning.model.Fluent('numberOfVessels', IntType())
bunkeringProviderVessel = unified_planning.model.Fluent('BunkeringProviderVessel', IntType(), v=Vessel)
bunkeringProviderBarge = unified_planning.model.Fluent('BunkeringProviderBarge ', IntType(),  b=Barge)
timeVesselStartAtAnchorage = unified_planning.model.Fluent('timeVesselStartAtAnchorage', IntType(), v=Vessel)



fuelRequiredVessel = unified_planning.model.Fluent('fuelRequiredVessel', IntType(), v=Vessel)
totalFuelBarge = unified_planning.model.Fluent('totalFuelBarge', IntType(), b=Barge)
actualFuelBarge = unified_planning.model.Fluent('actualFuelBarge', IntType(), b=Barge)


isRefuelZone = Fluent('isRefuelZone', BoolType(), p=Position)

active = Fluent('active', BoolType(), b=Barge)

priorityGlobal = Fluent('priority', IntType())

priorityVessel = Fluent('priorityVessel', IntType(), v=Vessel)



    # Define Objects
    
startPoint = unified_planning.model.Object('StartPoint', Position)
waitingPoint = unified_planning.model.Object('WaitingPoint', Position)
exit = unified_planning.model.Object('Exit', Position)


inactivo = unified_planning.model.Object('Inactivo', Position)




    # StartPoint_to_Anchorage
startPoint_to_Anchorage = DurativeAction('StartPoint_to_Anchorage', v=Vessel, b=Barge, p=Position)
v = startPoint_to_Anchorage.parameter('v')
b = startPoint_to_Anchorage.parameter('b')
p = startPoint_to_Anchorage.parameter('p')

    # Duration
startPoint_to_Anchorage.set_fixed_duration(timeInitToAnch(v))

    # Start Precondition
    
startPoint_to_Anchorage.add_condition(StartTiming(), Equals(priorityVessel(v), priorityGlobal))
startPoint_to_Anchorage.add_condition(StartTiming(), vessel_on(v, startPoint))

startPoint_to_Anchorage.add_condition(StartTiming(), isAnchorage(p))
startPoint_to_Anchorage.add_condition(StartTiming(), nextPosition(startPoint, p))
startPoint_to_Anchorage.add_condition(StartTiming(), Equals(bunkeringProviderVessel(v), bunkeringProviderBarge(b)))

    # End Precondition
startPoint_to_Anchorage.add_condition(EndTiming(), positionFree(p))

startPoint_to_Anchorage.add_condition(EndTiming(), active(b))
startPoint_to_Anchorage.add_condition(EndTiming(), bargeInUse(b))
startPoint_to_Anchorage.add_condition(EndTiming(), vesselBargePosition(v, b, p))
startPoint_to_Anchorage.add_condition(EndTiming(), vesselBarge(v, b))

startPoint_to_Anchorage.add_condition(EndTiming(), LE(fuelRequiredVessel(v), actualFuelBarge(b)))

startPoint_to_Anchorage.add_condition(EndTiming(), barge_on(b, p))



    # Start Action
    
startPoint_to_Anchorage.add_effect(StartTiming(), priorityGlobal, priorityGlobal+1)
startPoint_to_Anchorage.add_effect(StartTiming(), vessel_on(v, startPoint), False)
startPoint_to_Anchorage.add_effect(StartTiming(), vesselBargePosition(v, b, p), True)
startPoint_to_Anchorage.add_effect(StartTiming(), numberOfVessels, numberOfVessels-1)


    # End Action
startPoint_to_Anchorage.add_effect(EndTiming(), vessel_on(v, p), True)
startPoint_to_Anchorage.add_effect(EndTiming(), positionFree(p), False)




    # StartPoint_to_WaitingPoint 
startPoint_to_WaitingPoint = DurativeAction('StartPoint_to_WaitingPoint', v=Vessel)
v = startPoint_to_WaitingPoint.parameter('v')

    # Duration
startPoint_to_WaitingPoint.set_fixed_duration(timeInitToWait(v))

    # Start Precondition
    
startPoint_to_WaitingPoint.add_condition(StartTiming(), Equals(priorityVessel(v), priorityGlobal))
startPoint_to_WaitingPoint.add_condition(StartTiming(), vessel_on(v, startPoint))
startPoint_to_WaitingPoint.add_condition(StartTiming(), nextPosition(startPoint, waitingPoint))


    # Start Action
    
startPoint_to_WaitingPoint.add_effect(StartTiming(), priorityGlobal, priorityGlobal+1)
startPoint_to_WaitingPoint.add_effect(StartTiming(), vessel_on(v, startPoint), False)

startPoint_to_WaitingPoint.add_effect(StartTiming(), numberOfVessels, numberOfVessels-1)

    # End Action
startPoint_to_WaitingPoint.add_effect(EndTiming(), vessel_on(v, waitingPoint), True)




    # WaitingPoint_to_Anchorage
waitingPoint_to_Anchorage = DurativeAction('WaitingPoint_to_Anchorage', v=Vessel, b=Barge, p=Position)
v = waitingPoint_to_Anchorage.parameter('v')
b = waitingPoint_to_Anchorage.parameter('b')
p = waitingPoint_to_Anchorage.parameter('p')

    # Duration
waitingPoint_to_Anchorage.set_fixed_duration(timeWaitToAnch(v))

    # Start Precondition
    
waitingPoint_to_Anchorage.add_condition(StartTiming(), Equals(numberOfVessels, 0))
waitingPoint_to_Anchorage.add_condition(StartTiming(), vessel_on(v, waitingPoint))

waitingPoint_to_Anchorage.add_condition(StartTiming(), isAnchorage(p))
waitingPoint_to_Anchorage.add_condition(StartTiming(), nextPosition(waitingPoint, p))

waitingPoint_to_Anchorage.add_condition(StartTiming(), Equals(bunkeringProviderVessel(v), bunkeringProviderBarge(b)))


    # End Precondition
    
waitingPoint_to_Anchorage.add_condition(EndTiming(), positionFree(p))

waitingPoint_to_Anchorage.add_condition(EndTiming(), active(b))
waitingPoint_to_Anchorage.add_condition(EndTiming(), bargeInUse(b))
waitingPoint_to_Anchorage.add_condition(EndTiming(), vesselBargePosition(v, b, p))
waitingPoint_to_Anchorage.add_condition(EndTiming(), vesselBarge(v, b))

waitingPoint_to_Anchorage.add_condition(EndTiming(), LE(fuelRequiredVessel(v), actualFuelBarge(b)))

waitingPoint_to_Anchorage.add_condition(EndTiming(), barge_on(b, p))


    # Start Action
waitingPoint_to_Anchorage.add_effect(StartTiming(), vessel_on(v, waitingPoint), False)
waitingPoint_to_Anchorage.add_effect(StartTiming(), vesselBargePosition(v, b, p), True)

    # End Action
waitingPoint_to_Anchorage.add_effect(EndTiming(), vessel_on(v, p), True)
waitingPoint_to_Anchorage.add_effect(EndTiming(), positionFree(p), False)




    # VesselAtAnchorageAtStart 
vesselAtAnchorageAtStart = DurativeAction('VesselAtAnchorageAtStart', v=Vessel, p=Position)
v = vesselAtAnchorageAtStart.parameter('v')
p = vesselAtAnchorageAtStart.parameter('p')

    # Duration
vesselAtAnchorageAtStart.set_fixed_duration(timeVesselStartAtAnchorage(v))

    # Start Precondition
vesselAtAnchorageAtStart.add_condition(StartTiming(), GT(timeVesselStartAtAnchorage(v), 0))
vesselAtAnchorageAtStart.add_condition(StartTiming(), isAnchorage(p))
vesselAtAnchorageAtStart.add_condition(StartTiming(), Not(positionFree(p)))
vesselAtAnchorageAtStart.add_condition(StartTiming(), vessel_on(v, p))


    # Start Action
vesselAtAnchorageAtStart.add_effect(StartTiming(), numberOfVessels, numberOfVessels-1)

    # End Action
vesselAtAnchorageAtStart.add_effect(EndTiming(), isFueled(v), True)



    # BargeLocation_to_Anchorage 
bargeLocation_to_Anchorage = DurativeAction('BargeLocation_to_Anchorage', b=Barge, v=Vessel, p0=Position, p=Position)
b = bargeLocation_to_Anchorage.parameter('b')
v = bargeLocation_to_Anchorage.parameter('v')
p0 = bargeLocation_to_Anchorage.parameter('p0')
p = bargeLocation_to_Anchorage.parameter('p')

    # Duration
bargeLocation_to_Anchorage.set_fixed_duration(timeBargeLocationToAnchor(p0))

    # Start Precondition
    
bargeLocation_to_Anchorage.add_condition(StartTiming(), Equals(numberOfVessels, 0))

bargeLocation_to_Anchorage.add_condition(StartTiming(), active (b))
bargeLocation_to_Anchorage.add_condition(StartTiming(), Not(bargeInUse(b)))
bargeLocation_to_Anchorage.add_condition(StartTiming(), barge_on(b, p0))
bargeLocation_to_Anchorage.add_condition(StartTiming(), vesselBargePosition(v, b, p))
bargeLocation_to_Anchorage.add_condition(StartTiming(), nextPosition (p0, p))

    # End Precondition
bargeLocation_to_Anchorage.add_condition(EndTiming(), positionFree(p))

    # Start Action
bargeLocation_to_Anchorage.add_effect(StartTiming(), barge_on(b, p0), False)
bargeLocation_to_Anchorage.add_effect(StartTiming(), vesselBarge(v, b), True)
bargeLocation_to_Anchorage.add_effect(StartTiming(), bargeInUse(b), True)

    # End Action
bargeLocation_to_Anchorage.add_effect(EndTiming(), barge_on(b, p), True)




    # Bunkering  
bunkering = DurativeAction('Bunkering', v=Vessel, b=Barge, p=Position)
v = bunkering.parameter('v')
b = bunkering.parameter('b')
p = bunkering.parameter('p')

    # Duration
bunkering.set_fixed_duration(timeBunkering(v))

    # Start Precondition
    
bunkering.add_condition(StartTiming(), Equals(numberOfVessels, 0))

bunkering.add_condition(StartTiming(), active(b))
bunkering.add_condition(StartTiming(), vesselBargePosition(v, b, p))
bunkering.add_condition(StartTiming(), vesselBarge(v, b))
bunkering.add_condition(StartTiming(), vessel_on(v, p))
bunkering.add_condition(StartTiming(), barge_on(b, p))
bunkering.add_condition(StartTiming(), bargeInUse(b))


    # Start Action



    # End Action
bunkering.add_effect(EndTiming(), vesselBargePosition(v, b, p), False)
bunkering.add_effect(EndTiming(), vesselBarge(v, b), False)
bunkering.add_effect(EndTiming(), bargeInUse(b), False)
bunkering.add_effect(EndTiming(), isFueled(v), True)
bunkering.add_effect(EndTiming(),actualFuelBarge(b), actualFuelBarge(b)-fuelRequiredVessel(v))



    # Anchorage_to_Exit   
anchorage_to_Exit = DurativeAction('Anchorage_to_Exit', v=Vessel, p=Position)
v = anchorage_to_Exit.parameter('v')
p = anchorage_to_Exit.parameter('p')

    # Duration
anchorage_to_Exit.set_fixed_duration(timeAnchToExit(v))

    # Start Precondition
    
anchorage_to_Exit.add_condition(StartTiming(), Equals(numberOfVessels, 0))
anchorage_to_Exit.add_condition(StartTiming(), vessel_on(v, p))
anchorage_to_Exit.add_condition(StartTiming(), isAnchorage(p))
anchorage_to_Exit.add_condition(StartTiming(), isFueled(v))
anchorage_to_Exit.add_condition(StartTiming(), nextPosition(p, exit))

    # Start Action
anchorage_to_Exit.add_effect(StartTiming(), vessel_on(v, p), False)
anchorage_to_Exit.add_effect(StartTiming(), positionFree(p), True)


    # End Action
anchorage_to_Exit.add_effect(EndTiming(), vessel_on(v, exit), True)




    # BargeOnSite   
bargeOnSite = DurativeAction('BargeOnSite', b=Barge, v=Vessel, p=Position)
v = bargeOnSite.parameter('v')
p = bargeOnSite.parameter('p')
b = bargeOnSite.parameter('b')
    # Duration
bargeOnSite.set_fixed_duration(0)

    # Start Precondition
    
bargeOnSite.add_condition(StartTiming(), Equals(numberOfVessels, 0))

bargeOnSite.add_condition(StartTiming(), active(b))
bargeOnSite.add_condition(StartTiming(), Not(bargeInUse(b)))
bargeOnSite.add_condition(StartTiming(), barge_on(b, p))
bargeOnSite.add_condition(StartTiming(), vesselBargePosition(v, b, p))

    # Start Action
bargeOnSite.add_effect(StartTiming(), vesselBarge(v, b), True)
bargeOnSite.add_effect(StartTiming(), bargeInUse(b), True)



    # refueling
refueling = DurativeAction('Refueling Barge', b=Barge, p=Position)
b = refueling.parameter('b')
p = refueling.parameter('p')

refueling.set_fixed_duration(20)
refueling.add_condition(StartTiming(),  Equals(numberOfVessels, 0))
refueling.add_condition(StartTiming(), active(b))
refueling.add_condition(StartTiming(), isRefuelZone(p))
refueling.add_condition(StartTiming(), barge_on(b, p))
refueling.add_condition(StartTiming(), LT(actualFuelBarge(b), totalFuelBarge(b)))


refueling.add_effect(StartTiming(), active(b), False)

refueling.add_effect(EndTiming(), actualFuelBarge(b), totalFuelBarge(b))
refueling.add_effect(EndTiming(), active(b), True)


    # barge_to_refueling
barge_to_refueling = DurativeAction('barge_to_refueling', b=Barge, p0=Position, p = Position)
b = barge_to_refueling.parameter('b')
p = barge_to_refueling.parameter('p')
p0 = barge_to_refueling.parameter('p0')

barge_to_refueling.set_fixed_duration(20)
barge_to_refueling.add_condition(StartTiming(), Equals(numberOfVessels, 0))
barge_to_refueling.add_condition(StartTiming(), active(b))
barge_to_refueling.add_condition(StartTiming(), barge_on(b, p0))
barge_to_refueling.add_condition(StartTiming(), isRefuelZone(p))
barge_to_refueling.add_condition(StartTiming(), nextPosition(p0, p))
barge_to_refueling.add_condition(StartTiming(), Not(bargeInUse(b)))


barge_to_refueling.add_effect(StartTiming(), barge_on(b, p0), False)

barge_to_refueling.add_effect(EndTiming(), barge_on(b, p), True)




    # BeActive
beActive = DurativeAction('BeActive', b=Barge, p = Position)

b = beActive.parameter('b')
p = beActive.parameter('p')


beActive.set_fixed_duration(0)


beActive.add_condition(StartTiming(), Not(active(b)))

beActive.add_condition(StartTiming(), barge_on(b, inactivo))


beActive.add_effect(EndTiming(), active(b), True)
beActive.add_effect(EndTiming(), barge_on(b, inactivo), False)
beActive.add_effect(EndTiming(), barge_on(b, p), True)



    # BeInactive
beInactive = DurativeAction('BeInactive', b=Barge, p = Position)

b = beInactive.parameter('b')
p = beInactive.parameter('p')

beInactive.set_fixed_duration(0)

beInactive.add_condition(StartTiming(), active(b))

beInactive.add_condition(StartTiming(), barge_on(b, p))

beInactive.add_effect(EndTiming(), active(b), False)
beInactive.add_effect(EndTiming(), barge_on(b, inactivo), True)
beInactive.add_effect(EndTiming(), barge_on(b, p), False)



# Define Problem
problem = Problem('problemBunkering')

    # Add Fluents
problem.add_fluent(vessel_on, default_initial_value=False)
problem.add_fluent(barge_on, default_initial_value=False)
problem.add_fluent(isFueled, default_initial_value=False)
problem.add_fluent(nextPosition, default_initial_value=False)
problem.add_fluent(isAnchorage, default_initial_value=False)
problem.add_fluent(bargeInUse, default_initial_value=False)
problem.add_fluent(positionFree, default_initial_value=True)
problem.add_fluent(vesselBargePosition, default_initial_value=False)
problem.add_fluent(vesselBarge, default_initial_value=False)
problem.add_fluent(timeInitToAnch, default_initial_value=0)
problem.add_fluent(timeInitToWait, default_initial_value=0)
problem.add_fluent(timeWaitToAnch, default_initial_value=0)
problem.add_fluent(timeAnchToExit, default_initial_value=0)
problem.add_fluent(timeBunkering, default_initial_value=0)
problem.add_fluent(timeBargeLocationToAnchor, default_initial_value=0)
problem.add_fluent(numberOfVessels, default_initial_value=2)


problem.add_fluent(bunkeringProviderVessel, default_initial_value=0)
problem.add_fluent(bunkeringProviderBarge, default_initial_value=0)

problem.add_fluent(timeVesselStartAtAnchorage, default_initial_value=0)


problem.add_fluent(fuelRequiredVessel, default_initial_value=0)
problem.add_fluent(totalFuelBarge, default_initial_value=0)
problem.add_fluent(actualFuelBarge, default_initial_value=0)



problem.add_fluent(isRefuelZone, default_initial_value=False)



problem.add_fluent(active, default_initial_value=True)


problem.add_fluent(priorityGlobal, default_initial_value=1)
problem.add_fluent(priorityVessel, default_initial_value=0)

    #Add Objects


anchObjects = {}
for i in range(listData[0].deltaAnch_Capacity):
    aux = Object(f'Anchorage{i+1}', Position)
    problem.add_object(aux)
    problem.set_initial_value(nextPosition(startPoint, aux), True)
    problem.set_initial_value(nextPosition(waitingPoint, aux), True)    
    problem.set_initial_value(nextPosition(aux, exit), True)
    problem.set_initial_value(timeBargeLocationToAnchor(aux), 40)
    problem.set_initial_value(nextPosition(aux, exit), True)
    problem.set_initial_value(isAnchorage(aux), True)
    
    anchObjects.update({aux : False})
    



locationsBargeObject = {}
for location in listBargesLocations:    
    if location.location_type == 'Base Stations':
        aux = Object(location.location_name, Position)
        problem.add_object(aux)        
        problem.set_initial_value(timeBargeLocationToAnchor(aux), location.location_timeToAnch)
        locationsBargeObject.update({aux : False})
        
    elif location.location_type == 'Refueling Point':
        aux = unified_planning.model.Object(f'{location.location_name} - {location.location_type}', Position)
        problem.add_object(aux)        
        problem.set_initial_value(isRefuelZone(aux), True)
        for anchObjKey, anchObjValue in anchObjects.items():
            problem.set_initial_value(nextPosition(aux, anchObjKey), True)
            problem.set_initial_value(nextPosition(anchObjKey, aux), True)
        
        locationsBargeObject.update({aux : False})

    
for vessel in listVessels:
    aux = Object(vessel.name, Vessel)
    problem.add_object(aux)
    
    problem.add_timed_goal(EndTiming(), vessel_on(aux, exit))
    #Posiciones
    if(vessel.startAtAnchorage == "False"):
        problem.set_initial_value(vessel_on(aux, startPoint), True)
    elif(vessel.startAtAnchorage == "True"):
        for anchObjectsKey, anchObjectsValue in anchObjects.items():
            if anchObjectsValue == False:
                problem.set_initial_value(vessel_on(aux, anchObjectsKey), True) 
                anchObjects.update({anchObjectsKey : True})
                problem.set_initial_value(positionFree(anchObjectsKey), False)
                break 
            
            
    # Bunkering provider
    problem.set_initial_value(bunkeringProviderVessel(aux), vessel.bunkeringProvider)  
    problem.set_initial_value(priorityVessel(aux), vessel.priority)    


    problem.set_initial_value(fuelRequiredVessel(aux), vessel.fuelRequested)
        
    # Times
        
    problem.set_initial_value(timeInitToAnch(aux), vessel.timeToAnchorage)
    problem.set_initial_value(timeInitToWait(aux), vessel.timeToWaitingPoint)
    problem.set_initial_value(timeWaitToAnch(aux), vessel.timeFromWaitingPoint)
    problem.set_initial_value(timeAnchToExit(aux), vessel.timeFromAnchorage)
    problem.set_initial_value(timeBunkering(aux), vessel.bunkeringTime)
    problem.set_initial_value(timeVesselStartAtAnchorage(aux), vessel.timeStartAtAnchorage)
        
        # Add Goal
    problem.add_timed_goal(EndTiming(), vessel_on(aux, exit))
        
        
    
    
for barge in listBarges:
    aux = Object(barge.name, Barge)
    problem.add_object(aux)
    problem.set_initial_value(bunkeringProviderBarge(aux), barge.companyLegalCode) 
    problem.set_initial_value(actualFuelBarge(aux), barge.fuelAvailable)        
    problem.set_initial_value(totalFuelBarge(aux), barge.fuelCapacity)
    
    problem.add_timed_goal(StartTiming(19), barge_on(aux, inactivo))
    
    problem.add_timed_goal(StartTiming(80), barge_on(aux, list(locationsBargeObject.keys())[0]))
    
        #Posiciones    

    for locObjectKey, locObjectValue in locationsBargeObject.items():
        if locObjectValue == False:
            if 'BaseStation' in locObjectKey.name:
                problem.set_initial_value(barge_on(aux, locObjectKey), True) 
                locationsBargeObject.update({locObjectKey : True})
                break 
        
# Relations between Barges and Anch
for locBargeKey, locBargeValue in locationsBargeObject.items():
    for anchObjKey, anchObjValue in anchObjects.items():
        problem.set_initial_value(nextPosition(locBargeKey, anchObjKey), True)

# Relations between Anchs
for locBargeKey, locBargeValue in locationsBargeObject.items():
    for locBargeKey2, locBargeValue2 in locationsBargeObject.items():
        if locBargeKey.name != locBargeKey2.name:
                problem.set_initial_value(nextPosition(locBargeKey, locBargeKey2), True)
            
# Relations between Anchs
for anchObjKey1, anchObjValue1 in anchObjects.items():
    for anchObjKey2, anchObjValue2 in anchObjects.items():
        if anchObjKey1.name != anchObjKey2.name:
            problem.set_initial_value(nextPosition(anchObjKey1, anchObjKey2), True)


problem.add_object(startPoint)
problem.add_object(waitingPoint)

problem.add_object(inactivo)
problem.add_object(exit)

    # Add Actions
problem.add_action(startPoint_to_Anchorage)

problem.add_action(startPoint_to_WaitingPoint)

problem.add_action(waitingPoint_to_Anchorage)

problem.add_action(bargeLocation_to_Anchorage)


problem.add_action(vesselAtAnchorageAtStart)

problem.add_action(bunkering)

problem.add_action(anchorage_to_Exit)

problem.add_action(bargeOnSite)


problem.add_action(refueling)


problem.add_action(barge_to_refueling)


problem.add_action(beActive)

problem.add_action(beInactive)





    # Define Initial state

problem.set_initial_value(nextPosition(startPoint, waitingPoint), True)



    # Add Timed Goal

problem.add_timed_goal(StartTiming(1), Equals(numberOfVessels, 0))








now = datetime.now()
folder = f'{directory.split("/")[0]}/{directory.split("/")[1]}/{directory.split("/")[2]}/{directory.split("/")[3]}/{directory.split("/")[4]}/Output/'
os.makedirs(folder, exist_ok=True)
with open(f'{folder}/pddlProblem.pddl', mode='w', newline='') as file:
    file.write(f'{problem}')
        
        
        

# Solve Problem with OneshotPlanner
# Enhsp
with OneshotPlanner(name='tamer') as planner:
    result = planner.solve(problem)
    
    if result.status == up.engines.PlanGenerationResultStatus.SOLVED_SATISFICING:
         print("Tamer returned: %s" % result.plan)
    else:
         print("No plan found.")

strplan = ("%s" % result.plan)

planning = strplan.split('\n')


count = 1
planning_results= {}
barges_results = {}
barges_other = {}
vessels_results = {}

for inst in planning:
    
    if "StartPoint_to_Anchorage" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        vessel = inst.split("(")[1].split(",")[0]
        destine = inst.split(",")[2].split(")")[0].strip()
        
        
        #Planning Result output
        planning_results.update({count : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'StartPoint_to_Anchorage'
                                        , 'Duration':duration, 'Vessel': vessel, 'Origin': "InitialZone"
                                        , 'Destine':destine}})
        
        #Vessel Output
        vessels_results.update({ f'{vessel} - RTA':endTime, f'{vessel} - timeToAnch': duration})
        
        
        count =count+1
        
    elif "StartPoint_to_WaitingPoint" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        vessel = inst.split("(")[1].split(",")[0]
        
        #Planning Result output
        planning_results.update({count : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'StartPoint_to_WaitingPoint'
                                        , 'Duration':duration, 'Vessel': vessel, 'Origin': "InitialZone"
                                        , 'Destine':destine}})
        
        #Vessel Output
        vessels_results.update({ f'{vessel} - RTA':endTime, f'{vessel} - timeToAnch': duration})
                
        
        count =count+1
        
        
    elif "WaitingPoint_to_Anchorage" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        vessel = inst.split("(")[1].split(",")[0]
        
        
        #Planning Result output
        planning_results.update({count : {'Item':count,'Action_InitTime': list(planning_results.values())[list(planning_results).count-1].endTime, 'Action_EndTime':initTime, 'Action_Description':'Waiting Time'
                                        , 'Duration': initTime - list(planning_results.values())[list(planning_results).count-1].endTime, 'Vessel': vessel, 'Origin': "WaitingPoint"}})
        
        planning_results.update({count : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'WaitingPoint_to_Anchorage'
                                        , 'Duration':duration, 'Vessel': vessel, 'Origin': "WaitingPoint"
                                        , 'Destine':destine}})
        
        #Vessel Output
        vessels_results.update({ f'{vessel} - RTA':endTime, f'{vessel} - timeToAnch': duration})
                
        
        count =count+1
        
        
    elif "BargeLocation_to_Anchorage" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        barge = inst.split("(")[1].split(",")[0]
        vessel = inst.split(",")[1].split(",")[0].strip()
        origin = inst.split(",")[2].split(")")[0].strip()        
        destine = inst.split(",")[3].split(")")[0].strip()
        
        #Planning Result output
        planning_results.update({count : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'BargeLocation_to_Anchorage'
                                        , 'Duration':duration, 'Barge': barge, 'Vessel':vessel, 'Origin': origin
                                        , 'Destine':destine}})
        #Barge Output
        barges_results.update({f'{count} - {barge}'  : {'BargePlannedMovement_name': f"BargeLocation_to_Anchorage({vessel})", 'BargePlannedMovement_initTime':initTime, 
                                        'BargePlannedMovement_EndTime':endTime,'BargePlannedMovement_Origin': origin,
                                        'BargePlannedMovement_Destine': destine,'BargePlannedMovement_Duration':duration}})
        count =count+1   
        
        
    elif "Refueling Barge" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        barge = inst.split("(")[1].split(",")[0]
        origin = inst.split(",")[1].split(")")[0].strip()        
        
        #Planning Result output
        planning_results.update({count : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'Refueling Barge'
                                        , 'Duration':duration, 'Barge': barge,'Origin': origin}})
        #Barge Output
        barges_results.update({f'{count} - {barge}'  : {'BargePlannedMovement_name': f"Refueling Barge", 'BargePlannedMovement_initTime':initTime, 
                                        'BargePlannedMovement_EndTime':endTime,'BargePlannedMovement_Origin': origin, 'BargePlannedMovement_Duration':duration}})
        
        barges_other.update({f'{count} - {barge}'  : {'Description': f"Refueling Barge", 'Real Time':0, 
                                        'Planification':duration}})
        count =count+1

     
    elif "barge_Refueling_to_Anch" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        barge = inst.split("(")[1].split(",")[0]
        origin = inst.split(",")[1].split(")")[0].strip()
        destine = inst.split(",")[2].split(")")[0].strip()
        
        #Planning Result output
        planning_results.update({count : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'barge_Refueling_to_Anch'
                                        , 'Duration':duration, 'Barge': barge,'Origin': origin, 'Destine': destine}})
        #Barge Output
        barges_results.update({f'{count} - {barge}'  : {'BargePlannedMovement_name': f"barge_Refueling_to_Anch", 'BargePlannedMovement_initTime':initTime, 
                                        'BargePlannedMovement_EndTime':endTime,'BargePlannedMovement_Origin': origin, 'BargePlannedMovement_Destine': destine, 'BargePlannedMovement_Duration':duration}})
        count =count+1
             
    elif "barge_to_refueling" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        barge = inst.split("(")[1].split(",")[0]
        origin = inst.split(",")[1].split(")")[0].strip()
        destine = inst.split(",")[2].split(")")[0].strip()
        
        #Planning Result output
        planning_results.update({count : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'barge_to_refueling'
                                        , 'Duration':duration, 'Barge': barge,'Origin': origin, 'Destine': destine}})
        #Barge Output
        barges_results.update({f'{count} - {barge}'  : {'BargePlannedMovement_name': f"barge_to_refueling", 'BargePlannedMovement_initTime':initTime, 
                                        'BargePlannedMovement_EndTime':endTime,'BargePlannedMovement_Origin': origin, 'BargePlannedMovement_Destine': destine, 'BargePlannedMovement_Duration':duration}})
        count =count+1
        

    elif "BargeOnSite" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        barge = inst.split("(")[1].split(",")[0]
        origin = inst.split(",")[2].split(")")[0].strip()        
        
        
        #Planning Result output
        planning_results.update({f'{count} - {barge}'  : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'BargeOnSite'
                                        , 'Duration':duration, 'Barge': barge, 'Origin': origin}})
        
        #Barge Output
        barges_results.update({f'{count} - {barge}'  : {'BargePlannedMovement_name': f"BargeOnSite", 'BargePlannedMovement_initTime':initTime, 
                                        'BargePlannedMovement_EndTime':endTime,'BargePlannedMovement_Origin': origin,
                                        'BargePlannedMovement_Duration':duration}})
        count =count+1


    elif "Bunkering" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        vessel = inst.split("(")[1].split(",")[0]
        barge = inst.split(",")[1].split(",")[0].strip()
        origin = inst.split(",")[2].split(")")[0].strip()        
        
        #Planning Result output
        planning_results.update({count : {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'Bunkering'
                                        , 'Duration':duration, 'Barge': barge, 'Vessel':vessel, 'Origin': origin}})
        
        #Barge Output
        barges_results.update({f'{count} - {barge}' : {'BargePlannedMovement_name': f"Bunkering ({vessel})", 'BargePlannedMovement_initTime':initTime, 
                                        'BargePlannedMovement_EndTime':endTime,'BargePlannedMovement_Origin': origin,
                                        'BargePlannedMovement_Duration':duration}})
        
        #Vessel Output
        vessels_results.update({f'{vessel} - bunkering': duration}) 
        
        
        count =count+1


    elif "Anchorage_to_Exit" in inst:
        initTime = inst.split(":")[0].strip().split(".")[0]
        duration = inst.split("[")[1].split("]")[0].split(".")[0]
        endTime = int(initTime) + int(duration)
        vessel = inst.split("(")[1].split(",")[0]
        origin = inst.split(",")[1].split(")")[0].strip()
        
        
        #Planning Result output
        planning_results.update({count: {'Item':count,'Action_InitTime':initTime, 'Action_EndTime':endTime, 'Action_Description':'Anchorage_to_Exit'
                                        , 'Duration':duration, 'Vessel':vessel, 'Origin': origin
                                        , 'Destine':"Exit"}})
        
        #Vessel Output
        vessels_results.update({f'{vessel} - timeLeave':duration, f'{vessel} - endTime': endTime}) 
        
        count =count+1
 


with open(f'{folder}/planning_results.csv', mode='w', newline='') as file:
    writer = csv.DictWriter(file, delimiter=',', fieldnames=['Item', 'Action_InitTime', 'Action_EndTime', 'Action_Description', 'Duration', 'Vessel', 'Barge', 'Origin', 'Destine'] )
    writer.writeheader()


    for res in planning_results.values():
        writer.writerow(res)
        
        
        
for barge in listBarges:    
    with open(f'{folder}/{barge.name}_BargeOtherOperations_results.csv', mode='w', newline='') as file:
        writer = csv.DictWriter(file, delimiter=',', fieldnames=['Description', 'Real Time', 'Planification'])
        writer.writeheader()



        for bargeResKey, bargeResValue in barges_other.items():
            if  barge.name in bargeResKey:
                writer.writerow(bargeResValue)
                
                
                
                

for barge in listBarges:    
    with open(f'{folder}/{barge.name}_BargeActualEvents_results.csv', mode='w', newline='') as file:
        writer = csv.DictWriter(file, delimiter=',', fieldnames=['BargeActualEvent_name', 'BargeActualEvent_initTime', 'BargeActualEvent_EndTime',
                                                                'BargeActualEvent_Origin', 'BargeActualEvent_Destine', 'BargeActualEvent_Duration'])
        writer.writeheader()



        for bargeAct in listBargesActualEvents:
            if  barge.name in bargeAct.name:
                writer.writerow({'BargeActualEvent_name': bargeAct.type, 'BargeActualEvent_initTime': bargeAct.initTime, 'BargeActualEvent_EndTime': bargeAct.endTime,
                                'BargeActualEvent_Origin': bargeAct.origin, 'BargeActualEvent_Destine': bargeAct.destination, 'BargeActualEvent_Duration': bargeAct.duration})
                
    
for barge in listBarges:    
    with open(f'{folder}/{barge.name}_BargePlannedEvents_results.csv', mode='w', newline='') as file:
        writer = csv.DictWriter(file, delimiter=',', fieldnames=['BargePlannedMovement_name', 'BargePlannedMovement_initTime', 'BargePlannedMovement_EndTime',
                                                                'BargePlannedMovement_Origin', 'BargePlannedMovement_Destine', 'BargePlannedMovement_Duration'])
        writer.writeheader()



        for bargeResKey, bargeResValue in barges_results.items():
            if  barge.name in bargeResKey:
                writer.writerow(bargeResValue)
    


    


for vessel in listVessels:    
    with open(f'{folder}/{vessel.name}_results.csv', mode='w', newline='') as file:
        writer = csv.DictWriter(file, delimiter=',', fieldnames=['Description','Real Time', 'Planification'])
               
        writer.writeheader()

        
        for vesselResKey, vesselResValue in vessels_results.items():
            
            if vessel.name in vesselResKey:
                if 'RTA' in vesselResKey:                     
                    writer.writerow({'Description':'Requested time of arrival (RTA)', 'Planification': time.strftime("%H:%M:%S", time.gmtime(int(vesselResValue)*60)), 'Real Time':time.strftime("%H:%M:%S", time.gmtime(int(vesselResValue)*60))})
                
                if 'timeToAnch' in vesselResKey: 
                    writer.writerow({'Description':'Navegation Time to Delta Anchorage', 'Planification':vesselResValue, 'Real Time': vessel.etaAnch})                
               
                if 'timeToAnch' in vesselResKey:         
                        writer.writerow({'Description':'Waiting Time', 'Planification':0, 'Real Time': vessel.waitingTime})
                        
                if 'timeToAnch' in vesselResKey:             
                        writer.writerow({'Description':'Idle Time', 'Planification':0})        
                
                if 'bunkering' in vesselResKey:         
                        writer.writerow({'Description':'Bunkering Time', 'Planification':vesselResValue, 'Real Time': int(vessel.atcBunk) - int(vessel.atsBunk)})                
                    
                if 'bunkering' in vesselResKey:   
                        writer.writerow({'Description':'Fuel Supplied', 'Planification':vessel.fuelRequested, 'Real Time':vessel.fuelActuallyDelivered})

                if 'bunkering' in vesselResKey: 
                        writer.writerow({'Description':'Other Activities', 'Planification':''})
             
                if 'timeLeave' in vesselResKey: 
                        writer.writerow({'Description':'Navegation Time to leave Delta Anchorage', 'Planification':vesselResValue, 'Real Time': vessel.atdBerth})
                
                if 'endTime' in vesselResKey: 
                        writer.writerow({'Description':'TOTAL TIME', 'Planification':vesselResValue, 'Real Time': vessel.atdPBP}) 
                    
                          
            

    
# plot_plan(result.plan, figsize=[20, 15])