import pickle
import random
import unittest
import uuid
from datetime import timedelta

from app.App import App
from core.domain.map.GeoLocation import GeoLocation
from core.domain.optimization.TransportMode import TransportMode
from core.domain.optimization.OptimizationPoint import OptimizationPoint
from core.domain.optimization.OptimizationPointType import OptimizationPointType
from core.domain.optimization.OptimizationPostman import OptimizationPostman
from core.domain.optimization.OptimizationVehicle import OptimizationVehicle
from core.domain.map.PostOffice import PostOffice
from core.extend import fs
from core.types.Id import Id


class test_OptimizationService(unittest.TestCase):

	@classmethod
	def setUpClass(cls):
		App.init()

	def test_vrpOptimization_original(self):
		optimizationPointsNum = 50
		optimizationId = Id()

		random.seed(a=0)

		randomVehicleType = lambda num: [x for x in list(random.sample(sorted(list(TransportMode.__members__.values())), num))]

		optimizationPostman = [
			OptimizationPostman(
				optimizationId=optimizationId,
				deliveryTime=random.uniform(a=4.0, b=8.0),
				vehicleTypes=randomVehicleType(num=random.randint(1, 3)),
				quantity=random.randint(1, 5)
			) for _ in range(5)
		]
		print("\nPostmans:")
		for x in optimizationPostman:
			print(f"\t- {x}")

		optimizationVehicles = [
			OptimizationVehicle(
				optimizationId=optimizationId,
				name="name",
				category=randomVehicleType(1)[0],
				capacity=random.randint(10, 50),
				range=random.randint(50, 100),
				minQuantity=0,
				maxQuantity=3,
				deliverySpeed=12,
				travelingSpeed=12,
				navigatingSpeed=12,
			) for _ in range(10)
		]
		print("\nVehicles:")
		for x in optimizationVehicles:
			print(f"\t- {x}")

		optimizationPoints = [OptimizationPoint(
			id=str(uuid.uuid4()),
			address="",
			location=GeoLocation(0, 0),
			polygon=[],
			type=OptimizationPointType.DEPOT,
			serviceTime=timedelta(seconds=0),
			demand=0,
			stopTimes=[]
		)] + [OptimizationPoint(
			id=str(uuid.uuid4()),
			address="",
			location=GeoLocation(0, 0),
			polygon=[],
			type=OptimizationPointType.CRN,
			serviceTime=timedelta(seconds=1),
			demand=1,
			stopTimes=[]
		) for _ in range(optimizationPointsNum)]
		print("\nPoints:")
		for x in optimizationPoints:
			print(f"\t- {x}")

		distanceMatrix: dict[TransportMode, list[list[int]]] = {}
		durationMatrix: dict[TransportMode, list[list[int]]] = {}
		for k, v in TransportMode.__members__.items():
			distanceMatrix[v] = [[random.randint(1, 2) for _ in range(len(optimizationPoints) + 10)] for _ in range(len(optimizationPoints) + 10)]
			durationMatrix[v] = [[random.randint(1, 2) for _ in range(len(optimizationPoints) + 10)] for _ in range(len(optimizationPoints) + 10)]
			for i in range(optimizationPointsNum):
				distanceMatrix[v][i][i] = 0
				durationMatrix[v][i][i] = 0

		optimizationRoutes = App.services.optimizationService.vrpOptimization(
			postOffice=PostOffice(postalCode="1000", name="name", location="location", address="address", unitType="CRN"),
			solvingTime=timedelta(seconds=20),
			optimizationPostman=optimizationPostman,
			optimizationVehicles=optimizationVehicles,
			optimizationPoints=optimizationPoints[:100],
			distanceMatrix=distanceMatrix,
			durationMatrix=durationMatrix
		)
		print(optimizationRoutes)

	def test_readOptimizationFiles(self):
		files = App.usecases.read_optimization_files.now(posta="1000")
		print(files)