from typing import Optional

from dotenv import load_dotenv

from app.repos.sql.CrnMicroUpdateSqlRepo import CrnMicroUpdateSqlRepo
from app.repos.sql.GpsServiceTimeSqlRepo import GpsServiceTimeSqlRepo
from app.repos.sql.GpsSqlRepo import GpsSqlRepo
from app.repos.sql.GpsStopTimeSqlRepo import GpsStopTimeSqlRepo
from app.repos.sql.GpsDeliverySqlRepo import GpsDeliverySqlRepo
from app.repos.sql.OptimizationMetricsSqlRepo import OptimizationMetricsSqlRepo
from app.services.FsFtpService import FsFtpService
from app.services.OsrmRoutingService import OsrmRoutingService
from app.services.SolvesallOptimizationService import SolvesallOptimizationService
from core.domain.worker.Worker import Worker
from core.repos.CrnMicroUpdateRepo import CrnMicroUpdateRepo
from core.repos.GpsDeliveryRepo import GpsDeliveryRepo
from core.repos.GpsRepo import GpsRepo
from core.repos.GpsServiceTimeRepo import GpsServiceTimeRepo
from core.repos.GpsStopTimeRepo import GpsStopTimeRepo
from core.types.Id import Id
from core.usecases.Print_file_hashes import Print_file_hashes
from core.usecases.Run_gps_worker import Run_gps_worker
from core.usecases.gps_worker.Analyze_delivery_data import Analyze_delivery_data
from core.usecases.gps_worker.Analyze_gps_data import Analyze_gps_data
from core.usecases.gps_worker.Match_crnPoints_with_allLandPlots import Match_crnPoints_with_allLandPlots
from core.usecases.gps_worker.Match_crnPoints_with_landPlots import Match_crnPoints_with_landPlots
from core.usecases.gps_worker.Update_service_times import Update_service_times
from core.usecases.optimization_worker.Update_optimization_points import Update_optimization_points
from core.usecases.updating_worker.Test_transport_matrix import Test_transport_matrix

load_dotenv()

from sqlalchemy import create_engine

from app.Env import Env
from app.repos.sql.GpsSessionSqlRepo import GpsSessionSqlRepo
from app.repos.sql.OptimizationResultSqlRepo import OptimizationResultSqlRepo
from app.repos.sql.OptimizationSqlRepo import OptimizationSqlRepo
from app.repos.sql.OptimizationVehicleSqlRepo import OptimizationVehicleSqlRepo
from app.repos.sql.PostOfficeSqlRepo import PostOfficeSqlRepo
from app.repos.sql.WorkerJobLogSqlRepo import WorkerJobLogSqlRepo
from app.repos.sql.WorkerJobSqlRepo import WorkerJobSqlRepo
from app.repos.sql.WorkerJobStatusSqlRepo import WorkerJobStatusSqlRepo
from app.repos.sql.WorkerLogSqlRepo import WorkerLogSqlRepo
from app.repos.sql.WorkerSqlRepo import WorkerSqlRepo
from app.repos.sql.WorkerStatusSqlRepo import WorkerStatusSqlRepo
from app.services.EProstorLandService import EProstorLandService
from app.services.PostaApiService import PostaApiService
from app.services.PsutilSystemService import PsutilSystemService
from core.domain.worker.WorkerJob import WorkerJob
from core.repos.GpsSessionRepo import GpsSessionRepo
from core.repos.OptimizationRepo import OptimizationRepo
from core.repos.OptimizationResultRepo import OptimizationResultRepo
from core.repos.OptimizationVehicleRepo import OptimizationVehicleRepo
from core.repos.PostOfficeRepo import PostOfficeRepo
from core.repos.WorkerJobLogRepo import WorkerJobLogRepo
from core.repos.WorkerJobRepo import WorkerJobRepo
from core.repos.WorkerJobStatusRepo import WorkerJobStatusRepo
from core.repos.WorkerLogRepo import WorkerLogRepo
from core.repos.WorkerRepo import WorkerRepo
from core.repos.WorkerStatusRepo import WorkerStatusRepo
from core.services.FtpService import FtpService
from core.services.LandService import LandService
from core.services.OptimizationService import OptimizationService
from core.services.PostaService import PostaService
from core.services.RoutingService import RoutingService
from core.services.SystemService import SystemService
from core.usecases.Run_optimization_worker import Run_optimization_worker
from core.usecases.Run_updating_worker import Run_updating_worker
from core.usecases.optimization_worker.Read_optimization_files import Read_optimization_files
from core.usecases.updating_worker.Calculate_optimization_points import Calculate_optimization_points
from core.usecases.updating_worker.Write_optimization_files import Write_optimization_files
from core.usecases.initialization.Register_worker import Register_worker
from core.usecases.optimization_worker.Run_optimization_job import Run_optimization_job
from core.usecases.logging.Log_worker_job_status import Log_worker_job_status
from core.usecases.logging.Log_worker_status import Log_worker_status


class App:
	# REPOS
	class repos:
		optimizationResultRepo: OptimizationResultRepo = None
		optimizationRepo: OptimizationRepo = None
		optimizationVehicleRepo: OptimizationVehicleRepo = None
		workerRepo: WorkerRepo = None
		workerLogRepo: WorkerLogRepo = None
		workerStatusRepo: WorkerStatusRepo = None
		workerJobRepo: WorkerJobRepo = None
		workerJobStatusRepo: WorkerJobStatusRepo = None
		workerJobLogRepo: WorkerJobLogRepo = None
		gpsSessionRepo: GpsSessionRepo = None
		gpsRepo: GpsRepo = None
		gpsStopTimeRepo: GpsStopTimeRepo = None
		gpsServiceTimeRepo: GpsServiceTimeRepo = None
		gpsDeliveryRepo: GpsDeliveryRepo = None
		postOfficeRepo: PostOfficeRepo = None
		crnMicroUpdateRepo: CrnMicroUpdateRepo = None

	# SERVICES
	class services:
		postaService: PostaService = None
		systemService: SystemService = None
		ftpService: FtpService = None
		routingService: RoutingService = None
		landService: LandService = None
		optimizationService: OptimizationService = None

	# USE CASES
	class usecases:
		run_gps_worker: Run_gps_worker = None
		print_file_hashes: Print_file_hashes = None
		analyze_gps_data: Analyze_gps_data = None
		analyze_delivery_data: Analyze_delivery_data = None
		update_service_times: Update_service_times = None
		match_crnPoints_with_landPlots: Match_crnPoints_with_landPlots = None
		match_crnPoints_with_allLandPlots: Match_crnPoints_with_allLandPlots = None
		test_transport_matrix: Test_transport_matrix = None
		log_worker_job_status: Log_worker_job_status = None
		log_worker_status: Log_worker_status = None
		register_worker: Register_worker = None
		run_optimization_worker: Run_optimization_worker = None
		run_updating_worker: Run_updating_worker = None
		write_optimization_files: Write_optimization_files = None
		calculate_optimization_points: Calculate_optimization_points = None
		read_optimization_files: Read_optimization_files = None
		update_optimization_points: Update_optimization_points = None

		@staticmethod
		def init_log_worker_status(id: Id[Worker]):
			db = create_engine(Env.DB_URL)
			workerStatusRepo = WorkerStatusSqlRepo(db=db)
			workerRepo = WorkerSqlRepo(db=db)
			systemService = PsutilSystemService()
			log_worker_status = Log_worker_status(
				workerRepo=workerRepo,
				workerStatusRepo=workerStatusRepo,
				systemService=systemService,
			)
			log_worker_status.now(id=id)

		@staticmethod
		def init_run_worker_optimization_job(workerJob: WorkerJob):
			db = create_engine(Env.DB_URL)

			# REPOS
			optimizationRepo = OptimizationSqlRepo(db=db)
			optimizationResultRepo = OptimizationResultSqlRepo(db=db)
			optimizationVehicleRepo = OptimizationVehicleSqlRepo(db=db)
			workerJobStatusRepo = WorkerJobStatusSqlRepo(db=db)
			workerJobLogRepo = WorkerJobLogSqlRepo(db=db)
			workerLogRepo = WorkerLogSqlRepo(db=db)
			postOfficeRepo = PostOfficeSqlRepo(db=db)
			gpsStopTimeRepo = GpsStopTimeSqlRepo(db=db)
			gpsServiceTimeRepo = GpsServiceTimeSqlRepo(db=db)
			optimizationMetricsRepo = OptimizationMetricsSqlRepo(db=db)
			gpsSessionRepo = GpsSessionSqlRepo(db=db)

			# SERVICES
			ftpService = FsFtpService()
			systemService = PsutilSystemService()
			routingService = OsrmRoutingService(domain=Env.ROUTING_DOMAIN_OSRM)
			optimizationService = SolvesallOptimizationService()
			postaService = PostaApiService(
				useMocks=Env.POSTA_API_USE_MOCKS,
				authDomain=Env.POSTA_API_AUTH,
				crnDomain=Env.POSTA_API_CRN,
				deliveryDomain=Env.POSTA_API_DELIVERY,
				username=Env.POSTA_API_USERNAME,
				password=Env.POSTA_API_PASSWORD,
				authToken=Env.POSTA_API_AUTH_TOKEN,
				crnToken=Env.POSTA_API_CRN_TOKEN,
				deliveryToken=Env.POSTA_API_DELIVERY_TOKEN,
			)


			# USE CASES
			log_worker_job_status = Log_worker_job_status(
				workerJobStatusRepo=workerJobStatusRepo,
				systemService=systemService,
			)

			update_service_times = Update_service_times(
				gpsStopTimeRepo=gpsStopTimeRepo,
				gpsServiceTimeRepo=gpsServiceTimeRepo,
				postaService=postaService,
				gpsSessionRepo=gpsSessionRepo,
			)

			read_optimization_files = Read_optimization_files(ftpService=ftpService)

			update_optimization_points = Update_optimization_points(
				gpsStopTimeRepo=gpsStopTimeRepo,
				gpsServiceTimeRepo=gpsServiceTimeRepo,
				update_service_times=update_service_times
			)

			run_worker_optimization_job = Run_optimization_job(
				optimizationMetricsRepo=optimizationMetricsRepo,
				systemService=systemService,
				workerLogRepo=workerLogRepo,
				workerJobLogRepo=workerJobLogRepo,
				log_worker_job_status=log_worker_job_status,
				optimizationVehicleRepo=optimizationVehicleRepo,
				optimizationRepo=optimizationRepo,
				postOfficeRepo=postOfficeRepo,
				read_optimization_files=read_optimization_files,
				optimizationResultRepo=optimizationResultRepo,
				optimizationService=optimizationService,
				routingService=routingService,
				update_optimization_points=update_optimization_points
			)

			run_worker_optimization_job.now(workerJob=workerJob)

	@staticmethod
	def init(maxCrnPoints: Optional[int] = None):
		db = create_engine(Env.DB_URL)

		# REPOS
		App.repos.optimizationRepo = OptimizationSqlRepo(db=db)
		App.repos.optimizationResultRepo = OptimizationResultSqlRepo(db=db)
		App.repos.optimizationVehicleRepo = OptimizationVehicleSqlRepo(db=db)
		App.repos.workerRepo = WorkerSqlRepo(db=db)
		App.repos.workerLogRepo = WorkerLogSqlRepo(db=db)
		App.repos.workerStatusRepo = WorkerStatusSqlRepo(db=db)
		App.repos.workerJobRepo = WorkerJobSqlRepo(db=db)
		App.repos.workerJobStatusRepo = WorkerJobStatusSqlRepo(db=db)
		App.repos.workerJobLogRepo = WorkerJobLogSqlRepo(db=db)
		App.repos.gpsSessionRepo = GpsSessionSqlRepo(db=db)
		App.repos.gpsRepo = GpsSqlRepo(db=db)
		App.repos.gpsStopTimeRepo = GpsStopTimeSqlRepo(db=db)
		App.repos.gpsServiceTimeRepo = GpsServiceTimeSqlRepo(db=db)
		App.repos.postOfficeRepo = PostOfficeSqlRepo(db=db)
		App.repos.crnMicroUpdateRepo = CrnMicroUpdateSqlRepo(db=db)
		App.repos.gpsDeliveryRepo = GpsDeliverySqlRepo(db=db)

		# SERVICES
		App.services.routingService = OsrmRoutingService(domain=Env.ROUTING_DOMAIN_OSRM)
		App.services.systemService = PsutilSystemService()
		App.services.optimizationService = SolvesallOptimizationService()
		App.services.landService = EProstorLandService()
		App.services.postaService = PostaApiService(
			useMocks=Env.POSTA_API_USE_MOCKS,
			authDomain=Env.POSTA_API_AUTH,
			crnDomain=Env.POSTA_API_CRN,
			deliveryDomain=Env.POSTA_API_DELIVERY,
			username=Env.POSTA_API_USERNAME,
			password=Env.POSTA_API_PASSWORD,
			authToken=Env.POSTA_API_AUTH_TOKEN,
			crnToken=Env.POSTA_API_CRN_TOKEN,
			maxCrnPoints=maxCrnPoints,
			deliveryToken=Env.POSTA_API_DELIVERY_TOKEN,
		)
		App.services.ftpService = FsFtpService()

		# USE CASES
		App.usecases.print_file_hashes = Print_file_hashes()

		App.usecases.log_worker_job_status = Log_worker_job_status(
			workerJobStatusRepo=App.repos.workerJobStatusRepo,
			systemService=App.services.systemService,
		)

		App.usecases.update_optimization_points = Update_optimization_points(
			gpsStopTimeRepo=App.repos.gpsStopTimeRepo,
			gpsServiceTimeRepo=App.repos.gpsServiceTimeRepo,
			update_service_times=App.usecases.update_service_times
		)

		App.usecases.log_worker_status = Log_worker_status(
			workerRepo=App.repos.workerRepo,
			workerStatusRepo=App.repos.workerStatusRepo,
			systemService=App.services.systemService
		)
		App.usecases.register_worker = Register_worker(
			workerRepo=App.repos.workerRepo,
			workerStatusRepo=App.repos.workerStatusRepo,
			workerLogRepo=App.repos.workerLogRepo,
			systemService=App.services.systemService,
		)
		App.usecases.run_optimization_worker = Run_optimization_worker(
			register_worker=App.usecases.register_worker,
			workerLogRepo=App.repos.workerLogRepo,
			optimizationRepo=App.repos.optimizationRepo,
			workerJobRepo=App.repos.workerJobRepo,
			init_run_optimization_job=App.usecases.init_run_worker_optimization_job,
			init_log_worker_status=App.usecases.init_log_worker_status,
			systemService=App.services.systemService,
			workerRepo=App.repos.workerRepo
		)

		App.usecases.read_optimization_files = Read_optimization_files(ftpService=App.services.ftpService)
		App.usecases.calculate_optimization_points = Calculate_optimization_points(
			gpsServiceTimeRepo=App.repos.gpsServiceTimeRepo,
			crnMicroUpdateRepo=App.repos.crnMicroUpdateRepo,
		)
		App.usecases.test_transport_matrix = Test_transport_matrix(routingService=App.services.routingService)
		App.usecases.match_crnPoints_with_landPlots = Match_crnPoints_with_landPlots(
			landService=App.services.landService,
			postaService=App.services.postaService,
		)
		App.usecases.match_crnPoints_with_allLandPlots = Match_crnPoints_with_allLandPlots(
			landService=App.services.landService,
			postaService=App.services.postaService,
		)
		App.usecases.write_optimization_files = Write_optimization_files(
			postOfficeRepo=App.repos.postOfficeRepo,
			crnMicroUpdateRepo=App.repos.crnMicroUpdateRepo,
			postaService=App.services.postaService,
			ftpService=App.services.ftpService,
			routingService=App.services.routingService,
			calculate_optimization_points=App.usecases.calculate_optimization_points,
			match_crnPoints_with_landPlots=App.usecases.match_crnPoints_with_landPlots
		)
		App.usecases.run_updating_worker = Run_updating_worker(
			register_worker=App.usecases.register_worker,
			workerLogRepo=App.repos.workerLogRepo,
			postOfficeRepo=App.repos.postOfficeRepo,
			write_optimization_files=App.usecases.write_optimization_files,
			gpsSessionRepo=App.repos.gpsSessionRepo,
			init_log_worker_status=App.usecases.init_log_worker_status,
			ftpService=App.services.ftpService,
		)

		App.usecases.analyze_gps_data = Analyze_gps_data(gpsRepo=App.repos.gpsRepo, postaService=App.services.postaService)
		App.usecases.analyze_delivery_data = Analyze_delivery_data(postaService=App.services.postaService)

		App.usecases.update_service_times = Update_service_times(
			gpsServiceTimeRepo=App.repos.gpsServiceTimeRepo,
			gpsStopTimeRepo=App.repos.gpsStopTimeRepo,
			postaService=App.services.postaService,
			gpsSessionRepo=App.repos.gpsSessionRepo
		)

		App.usecases.run_gps_worker = Run_gps_worker(
			init_log_worker_status=App.usecases.init_log_worker_status,
			register_worker=App.usecases.register_worker,
			workerLogRepo=App.repos.workerLogRepo,
			analyze_gps_data=App.usecases.analyze_gps_data,
			gpsSessionRepo=App.repos.gpsSessionRepo,
			gpsStopTimeRepo=App.repos.gpsStopTimeRepo,
			crnMicroUpdateRepo=App.repos.crnMicroUpdateRepo,
			update_service_times=App.usecases.update_service_times,
			analyze_delivery_data=App.usecases.analyze_delivery_data,
			gpsDeliveryRepo=App.repos.gpsDeliveryRepo,
			gpsServiceTimeRepo=App.repos.gpsServiceTimeRepo,
			match_crn_points_with_land_plots=App.usecases.match_crnPoints_with_landPlots,
			postaService=App.services.postaService
		)

		App.__check()

	@staticmethod
	def __check():
		not_inited = []
		for group in [App.repos, App.services, App.usecases]:
			for key, value in group.__dict__.items():
				if not str(key).startswith("_") and key not in ['init']:
					if value is None:
						not_inited.append(key)

		if len(not_inited) > 0:
			raise Exception(f"App dependencies not inited: {not_inited}")