from flask import current_app
from flask import g
from comicapi import comicarchive
from blinker import Namespace

from io import BytesIO
from wand.image import Image
import os, sys, re
import inspect

from scripts import database

rpi_signals = Namespace()
comic_loaded = rpi_signals.signal("comic-loaded")
movie_loaded = rpi_signals.signal("movie-loaded")
tv_show_loaded = rpi_signals.signal("tv_show_loaded")
tv_episodes_loaded = rpi_signals.signal("tv_episodes_loaded")

publishers_to_ignore = ["***REMOVED***"]

# Directories

RPI_COMICS_DIRECTORY = "/usb/storage/media/Comics/"
RPI_MOVIES_DIRECTORY = "/usb/storage/media/Videos/Movies/"
RPI_TV_SHOWS_DIRECTORY = "/usb/storage/media/Videos/TV/"
RPI_VIDEOS_DIRECTORY = "/usb/storage/media/Videos/Videos/"
RPI_GAMES_DIRECTORY = "/usb/storage/media/games/"
RPI_MUSIC_DIRECTORY = "/usb/storage/media/Music/"

MC_COMICS_DIRECTORY = "C:\\Users\\Matthew\\Documents\\Comics"

COMICS_DIRECTORY = RPI_COMICS_DIRECTORY if os.path.exists(RPI_COMICS_DIRECTORY) else MC_COMICS_DIRECTORY
MOVIES_DIRECTORY = RPI_MOVIES_DIRECTORY
TV_SHOWS_DIRECTORY = RPI_TV_SHOWS_DIRECTORY

#############


def get_comics():
	total_comics = 0
	comics_in_db = 0
	comics_added = 0
	meta = []
	thumbnails = []
	i = 0
	for root, dirs, files in os.walk(COMICS_DIRECTORY):
		for f in files:
			if "temp" in root:
				continue
			if f.endswith(".cbr"):
				total_comics += 1
				path = os.path.join(root, f)
				if not database.comic_path_in_db(path):
					try:
						test_path = path.encode("utf8")
					except Exception as e:
						current_app.logger.info("encoding failed on: "+path)
						continue
					archive = open_comic(path)
					md = archive.readCIX()
					if md.publisher in publishers_to_ignore:
						continue
					current_app.logger.info(path)
					try:
						meta.append((path, md))
						thumbnails.append(get_comic_thumbnails(archive))
						comics_added += 1
						i += 1
					except Exception as e:
						current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
						continue
					if i >= 2:
						comic_loaded.send("anonymous", meta=meta.copy(), thumbnails=thumbnails.copy())
						meta.clear()
						thumbnails.clear()
						i = 0
				comics_in_db += 1
	current_app.logger.info("total number of comics: "+str(total_comics))
	current_app.logger.info("comics in database: "+str(comics_in_db))
	current_app.logger.info("number of comics added: "+str(comics_added))
	comic_loaded.send("anonymous", meta=meta, thumbnails=thumbnails)


def get_comic(path):
	meta = []
	thumbnails = []
	if path.endswith(".cbr"):
		if not database.comic_path_in_db(path):
			try:
				test_path = path.encode("utf8")
			except Exception as e:
				current_app.logger.info("encoding failed on: "+path)
				return
			archive = open_comic(path)
			md = archive.readCIX()
			if md.publisher in publishers_to_ignore:
				return
			current_app.logger.info(path)
			meta.append((path, md))
			try:
				thumbnails.append(get_comic_thumbnails(archive))
			except Exception as e:
				current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
				return
			comic_loaded.send("anonymous", meta=meta, thumbnails=thumbnails)


def get_comic_thumbnails(comic):
	thumbnails = []
	size = "256x256"
	new_height = 256
	new_width = 256
	for page in range(comic.getNumberOfPages()):
		image_bytes = BytesIO(comic.getPage(page))
		image = Image(file=image_bytes)
		orig_height = image.height
		orig_width = image.width
		if orig_height >= orig_width:
			width = int((orig_width/orig_height) * new_height)
			height = new_height
		else:
			height = int((orig_height/orig_width) * new_width)
			width = new_width
		image.thumbnail(width, height)
		thumbnails.append((image.make_blob(), "image/"+image.format))
	return thumbnails


def open_comic(path):
	archive = comicarchive.ComicArchive(path, default_image_path="static/images/icon.png")
	return archive


def get_movies():
	current_app.logger.info("start load movies")
	pattern = r"(.+) \((....)\)(\(extended\))?( Director's Cut)?(\.mkv)"
	movies = []
	total_movies = 0
	movies_in_db = 0
	movies_added = 0
	for root, dirs, files in os.walk(MOVIES_DIRECTORY):
		for f in files:
			if f.endswith(".mkv"):
				total_movies += 1
				path = os.path.join(root, f)
				if not database.movie_path_in_db(path):
					try:
						match = re.fullmatch(pattern, f)
						if not match:
							current_app.logger.info(f+" did not match regex.")
							continue
						current_app.logger.info("movie path: "+path)
						title = match.group(1)
						current_app.logger.info("movie title: "+title)
						year = int(match.group(2))
						extended = False
						directors_cut = False
						if match.group(3):
							extended = True
							imdb_data = database.imdb_get_movie(title.replace(match.group(3), ""), year)
						elif match.group(4):
							imdb_data = database.imdb_get_movie(title.replace(match.group(4), ""), year)
							directors_cut = True
						else:
							imdb_data = database.imdb_get_movie(title, year)
						if not imdb_data:
							current_app.logger.info("could not get imdb data for: "+title+" "+str(year))
							continue
						imdb_id = imdb_data["tconst"]
						length = imdb_data["runtimeMinutes"]

						tmdb_data = database.tmdb_get_movie_by_imdb_id(imdb_id)
						if not tmdb_data:
							current_app.logger.info("could not get tmdb data")
							continue
						tmdb_id = tmdb_data[0]
						description = tmdb_data[1]
						poster_path = tmdb_data[2]
						backdrop_path = tmdb_data[3]
						movies_added += 1

						movies.append((path, imdb_id, tmdb_id, title, year, length, description, extended, directors_cut, poster_path, backdrop_path))
						if len(movies) >= 20:
							movie_loaded.send("anonymous", movies=movies.copy())
							movies.clear()
					except Exception as e:
						current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) +" "+ str(e))
						# print(e)
				movies_in_db += 1
	movie_loaded.send("anonymous", movies=movies)
	current_app.logger.info("finish load movies")
	current_app.logger.info("total movies: "+str(total_movies))
	current_app.logger.info("movies in database: "+str(movies_in_db))
	current_app.logger.info("movies added: "+str(movies_added))


def get_tv_shows():
	dir_pattern = r"(.+) \((....)\)"
	for dir in sorted(os.listdir(TV_SHOWS_DIRECTORY)):
		dir_match = re.fullmatch(dir_pattern, dir)
		if dir_match:
			path = TV_SHOWS_DIRECTORY+dir+"/"
			if not database.tv_show_path_in_db(path):
				series_name = dir_match.group(1)
				series_year = int(dir_match.group(2))
				imdb_data = database.imdb_get_tv_show(series_name, series_year)
				if not imdb_data:
					current_app.logger.info("could not get imdb data for:"+series_name+" "+str(series_year))
					# print("could not get imdb data for:", series_name, series_year)
					continue
				imdb_id = imdb_data["tconst"]
				tmdb_data = database.tmdb_get_tv_show_by_imdb_id(imdb_id)
				if not tmdb_data:
					current_app.logger.info("could not get tmdb data for:" + series_name + " " + str(series_year))
					# print("could not get tmdb data for:", series_name, series_year)
					with open("/usb/storage/rpiWebApp/log.txt", "a") as f:
						f.write("could not get tmdb data for: " + imdb_id + " " + series_name + " " + str(series_year)+"\n")
					continue
				tmdb_id = tmdb_data[0]
				description = tmdb_data[1]
				poster_path = tmdb_data[2]
				tv_show_data = (imdb_id, tmdb_id, series_name, series_year, description, poster_path, path)
				tv_show_loaded.send("anonymous", tv_show=tv_show_data)
	current_app.logger.info("finished load tv shows.")


def get_tv_episodes():
	try:
		video_pattern = r"S(\d+)E(\d+) - (.+)(.mp4|.mkv)"
		rows = database.get_all_tv_shows()
		for tv_show in rows:
			episodes = []
			for video in sorted(os.listdir(tv_show.path)):
				video_match = re.fullmatch(video_pattern, video)
				if video_match:
					path = tv_show.path + video
					if not database.tv_episode_path_in_db(path):
						season = int(video_match.group(1))
						episode = int(video_match.group(2))
						episode_name = video_match.group(3)
						episode_imdb_data = database.imdb_get_tv_episode(tv_show.imdb_id, season, episode)
						if not episode_imdb_data:
							current_app.logger.info("could not get imdb data for: "+tv_show.title+" "+str(tv_show.year)+" "+str(season)+" "+str(episode))
							print("could not get imdb data for:", tv_show.title, tv_show.year, season, episode)
							continue
						episode_imdb_id = episode_imdb_data["tconst"]
						episode_tmdb_data = database.tmdb_get_tv_episode_by_imdb_id(episode_imdb_id)
						if not episode_tmdb_data:
							current_app.logger.info("could not get tmdb data for: "+tv_show.title+" "+str(tv_show.year)+" "+str(season)+" "+str(episode))
							with open("/usb/storage/rpiWebApp/log.txt", "w") as f:
								f.write("could not get tmdb data for: " + episode_imdb_id + " " + tv_show.title + " " + str(
									tv_show.year) + " " + str(season) + " " + str(episode) + "\n")
							continue
						episode_tmdb_id = episode_tmdb_data[0]
						episode_description = episode_tmdb_data[1]
						episode_still_path = episode_tmdb_data[2]
						episodes.append((episode_imdb_id, tv_show.imdb_id, episode_tmdb_id, episode_name, season, episode,
										 episode_description, episode_still_path, path))
			tv_episodes_loaded.send("anonymous", tv_episodes=episodes)
		current_app.logger.info("finished load tv episodes.")
	except Exception as e:
		current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))