from domain.Logger import Logger


from pathlib import Path
import yaml


class ConfigFile:
	
	__VALID_TARGET_TYPES = [
		"file",
		"directory"
	]
	
	__VALID_DATE_DETECTION_TYPES = [
		"file"
	]
	
	def __init__(
			self, logger: Logger,
			path: Path,
	):
		
		self.__logger = logger
		self.__path = path.absolute()
		
		# noinspection PyTypeChecker
		self.__data: dict = None
		
		self.__dry_run: bool = True
		
		# noinspection PyTypeChecker
		self.__target_type: str = None
		
		# noinspection PyTypeChecker
		self.__date_detection: str = None
		
		self.__rotatable_paths: [Path] = []
		
		self.__minimum_items: int = 0
		# noinspection PyTypeChecker
		self.__maximum_items: int = None
		# noinspection PyTypeChecker
		self.__maximum_age: int = None
		
		self._load()
		self._consume()
		
	def __str__(self):
		
		s = ""
		
		s += "*** Config File ***"
		s += f"> Path: {self.__path}"
		s += f"> Dry run: " + ("Yes" if self.__dry_run else "No")
		s += f"> Minimum items: {self.__minimum_items}"
		s += f"> Maximum items: {self.__maximum_items}"
		s += f"> Maximum age (in days): {self.__maximum_age}"
		s += f"> Target type: {self.__target_type}"
		s += f"> Date detection: {self.__date_detection}"
		s += f"> Rotatable paths: "
		if len(self.__rotatable_paths) > 0:
			for p in self.__rotatable_paths:
				s += f">> {p}"
		else:
			s += ">> [none]"
		
		return s
	
	def _load(self):
		
		self.info(f"Loading config: {self.__path}")
		
		assert self.__path.is_file(), (
			f"Cannot load config file because it isn't a file: {self.__path}"
		)
		
		# Open the file
		self.debug(f"Opening config file for load: {self.__path}")
		f = open(str(self.__path))
		if not f:
			raise Exception(f"Unable to open config file: {self.__path}")
		
		# Load data
		self.__data = yaml.safe_load(f)
		assert self.__data is not None, (
			f"Config file seems to be null or empty: {self.__path}"
		)
		
		# Consume to internal
		self.info(f"Loaded config from path: {self.__path}")
	
	def _consume(self):
	
		try:
		
			if "options" in self.__data.keys():
				
				self.info(f"Found options setting")
				options = self.__data["options"]
				assert isinstance(options, dict), "Options must be a dict"
				
				if "dry-run" in options.keys():
					
					dry_run = self.__data["options"]["dry-run"]
					self.info(f"Found dry run option: {dry_run}")
					assert isinstance(dry_run, bool), "dry-run setting must be boolean"
					self.__dry_run = dry_run
				else:
					self.warning(f"No dry-run option found; Will use default: {self.__dry_run}")
				
				if "minimum-items" in options.keys():
					
					minimum_items = options["minimum-items"]
					self.info(f"Found minimum-items option: {minimum_items}")
					assert isinstance(minimum_items, int), (
						f"Option minimum-items must be int, but got: {minimum_items}"
					)
					self.__minimum_items = minimum_items
				else:
					self.warning(
						f"No minimum-items option found; Will use default: {self.__minimum_items}"
					)
				
				if "maximum-items" in options.keys():
					
					maximum_items = options["maximum-items"]
					self.info(f"Found maximum-items option: {maximum_items}")
					assert isinstance(maximum_items, int), (
						f"Option maximum-items must be int, but got: {maximum_items}"
					)
					assert maximum_items > 0, (
						f"Option maximum-items is zero, which doesn't make sense."
					)
					self.__maximum_items = maximum_items
				else:
					self.warning(
						f"No maximum-items option found; Will use default: {self.__maximum_items}"
					)
				
				if "maximum-age" in options.keys():
					
					maximum_age = options["maximum-age"]
					self.info(f"Found maximum-age option (max age in days): {maximum_age}")
					assert isinstance(maximum_age, int), (
						f"Option maximum-age must be int, but got: {maximum_age}"
					)
					assert maximum_age > 0, (
						f"Option maximum-age is zero, which doesn't make sense."
					)
					self.__maximum_age = maximum_age
				else:
					self.warning(
						f"No maximum-age option found; Will use default: {self.__maximum_age}"
					)
				
				assert "target-type" in options.keys(), (
					f"Option target-type is required"
				)
				target_type = options["target-type"]
				self.info(f"Found target-type option: {target_type}")
				assert isinstance(target_type, str), (
					f"Option target-type must be str, but got: {target_type}"
				)
				assert target_type in self.__VALID_TARGET_TYPES, (
					f"Option target-type must be one of: {self.__VALID_TARGET_TYPES}"
				)
				self.__target_type = target_type
				
				if "date-detection" in options.keys():
					date_detection = options["date-detection"]
					self.info(f"Found date-detection option: {date_detection}")
					assert isinstance(date_detection, str), (
						f"Option date-detection must be str, but got: {date_detection}"
					)
					assert date_detection in self.__VALID_DATE_DETECTION_TYPES, (
						f"Option date-detection must be one of: {self.__VALID_DATE_DETECTION_TYPES}"
					)
					self.__date_detection = date_detection
				else:
					self.warning(
						f"Option date-detection not found; Will use default: {self.__date_detection}"
					)
			
			assert "paths" in self.__data, (
				f"Could not find 'paths' key"
			)
			rotatable_paths = self.__data["paths"]
			if isinstance(rotatable_paths, str):
				rotatable_paths = [rotatable_paths]
			assert isinstance(rotatable_paths, list), (
				"Rotatable 'paths' key must be a string or list"
			)
			self.__rotatable_paths = rotatable_paths
			self.info(f"Found {len(self.__rotatable_paths)} rotatable paths")
		
		except KeyError as e:
			
			self.error(
				f"Failed to load config due to KeyError"
				f"\nFile: {self.__path}"
				f"\nError: {str(e)}"
			)
			raise e
		
		except AssertionError as e:
			
			self.error(
				f"Failed to load config due to AssertionError"
				f"\nFile: {self.__path}"
				f"\nError: {str(e)}"
			)
			raise e
	
	def debug(self, s):
		self.__logger.debug(f"({self.__path.name}) {s}")
	
	def info(self, s):
		self.__logger.info(f"({self.__path.name}) {s}")
	
	def warning(self, s):
		self.__logger.warning(f"({self.__path.name}) {s}")
	
	def error(self, s):
		self.__logger.error(f"({self.__path.name}) {s}")
	
	@property
	def key(self) -> str:
		return str(self.__path)
		
	@property
	def path(self) -> Path:
		return self.__path
	
	@property
	def data(self) -> dict:
		return self.__data
	
	@property
	def dry_run(self) -> bool:
		return self.__dry_run
	
	@dry_run.setter
	def dry_run(self, b: bool):
		self.__dry_run = b
	
	@property
	def target_type(self) -> str:
		return self.__target_type
	
	@property
	def date_detection(self) -> str:
		return self.__date_detection
	
	@property
	def rotatable_paths(self) -> [Path]:
		return self.__rotatable_paths
	
	@property
	def minimum_items(self) -> int:
		return self.__minimum_items
	
	@property
	def maximum_items(self) -> int:
		return self.__maximum_items

	@property
	def maximum_age(self) -> int:
		return self.__maximum_age