#!/usr/bin/env python

import argparse, json, sys, markdown, shutil, json, re, pathlib, shutil
import utils.imgconv

input_dir = None
output_dir = None
style = None
(W, H, FMT) = (None, None, None)
codebase = pathlib.Path(__file__).parent.absolute()

def translate_index_header(txt, dirname):
	sections = txt.count('- - -')
	if sections == 0:
		# not following the normal template -> direct html
		txt = txt.replace('data/', dirname + '/')   		#<--- replace reference to data/
		return txt
	elif sections == 1:
		[text, link] = txt.split('- - -')	

	text_md = markdown.markdown(text)
	link_info = json.loads(link)

	dirpath = pathlib.Path(dirname)
	img_name = pathlib.Path(link_info['img']).name
	img_path = dirpath / img_name
	img_resize_path = dirpath / "img-resize" / img_name

	picture_el = emit_picture(str(img_path), str(img_resize_path))
	
	table = codebase / "templates/<table>"
	with table.open(encoding="utf-8") as fp:
		out = fp.read()

	out = out.replace('[[text_md]]', text_md);
	out = out.replace('[[link_md]]', picture_el);
	if link_info['href']:
		if link_info['href'] == "data":
			href = dirname + "/"
		else:
			href = link_info['href']
		out = "<a href='" + href + "'>" + out + "</a>";
	return out

def escape_date(dirname):
	return re.sub('^20\d{2}?.', '', dirname)

def emit_picture(src_full, src_resize):
	return f'''<picture>
		<source media="(max-width: 799px)" srcset="{src_resize}" />
		<source media="(min-width: 800px)" srcset="{src_full}" />
		<img src="{src_full}" />
	</picture>'''


def emit_img(file: pathlib.Path, data_dir: pathlib.Path):

	## this is where LOD can be applied
	resize_dir = data_dir / "img-resize"
	resize_dir.mkdir(parents=True, exist_ok=True)
	filepath = data_dir / file
	resize_file = utils.imgconv.convert(filepath, (W, H, FMT), resize_dir)

	return f'<a href="{file}">' + emit_picture(str(file), "img-resize/" + resize_file.name) + '</a>'

def emit_video_mp4(file: pathlib.Path, data_dir: pathlib.Path):
	return f'<video controls><source src="{file}" type="video/mp4"</video>'

def emit_audio(file: pathlib.Path, data_dir: pathlib.Path, full=False):
	# an '.audio' file is a json file with a list of audio elements
	# which need to be bundles as a type of list in a single <li>

	if not file.is_file():
		file = data_dir / file;

	if file.is_file():
		with file.open() as fp:
			audio = json.loads(fp.read())
			if full:
				out = '<sound class="full">\n'
			else:
				out = "<sound>\n"
			for a in audio:
				out += "<track>\n"
				out += "<info>\n"
				out += "<name>" + a["name"] + "</name>\n"			
				#out += "<duration>" + a["length"] + "</duration>\n"
				out += "</info>\n"
				out += "<audio controls preload>\n"
				# if it is a list of files
				if isinstance(a["type"], list):
					for t in a["type"]:
						out += '<source src="' + a["file"] + '.' + t + '" type="audio/' + t + '">\n'
				else:
					out += '<source src="' + a["file"] + '" type="audio/' + a["type"] + '">\n'

				out += "</audio>\n"
				out += "</track>\n"

			out += "</sound>\n"

			return out

	return None

def emit_audio_full(file, data_dir):
	return emit_audio(file, data_dir, full=True)

def default(file, data_dir):
	return None;

content_map = {
	'.png': emit_img,
	'.jpg': emit_img,
	'.jpeg': emit_img,
	'.m4v': emit_video_mp4,
	'.mov': emit_video_mp4,
	'.mp4': emit_video_mp4,
	'.audio': emit_audio,
	'.audio_full': emit_audio_full,
	'.html': default,
	'.txt': default
};

def index_content(dir_name: str, data_dir: pathlib.Path, index_txt: pathlib.Path, desc_txt: pathlib.Path, template: str):

	print("	indexing content -- " + dir_name);

	# desc_txt is a markdown file containing description 
	# for the project - no layout applied to it, only md
	desc_md = None
	if desc_txt.is_file():
		with desc_txt.open(encoding="utf-8") as fp:
			desc_md = markdown.markdown(fp.read());

	# index_txt is a json file containing one thing:
	# an array of files names or glob patterns
	content_index = None
	if index_txt.is_file():
		with index_txt.open(encoding="utf-8") as fp:
			content_index = json.loads(fp.read());

	if desc_md is None and content_index is None:
		return;
	
	content_desc = ""
	content = ""

	if desc_md:
		content_desc += "<li>" + "<desc>" + "\n" + desc_md + "</desc>" + "</li>" + "\n";

	if content_index:

		files = [];
		for i in content_index:
			f = data_dir / i
			if f.is_file():		
				files.append(data_dir / i);
			else:
				files += [pathlib.Path(a.name) for a in list(data_dir.glob(i))]

		# sort files?
		files.sort()

		for j in files:
			ext = j.suffix.lower()
			if ext in content_map:
				element = content_map[ext](j, data_dir);
				if element:
					content += "<li>" + element + "</li>" + "\n";


	# check if there is an html file existing already. if so use that one.

	html = template.replace('[[content_desc]]', content_desc).replace('[[content]]', content).replace('[[dir]]', str(dir_name));

	try:
		out = data_dir / 'index.html'		
		with out.open('w', encoding="utf-8") as fp:
			fp.write(html);
		return out
	except:
		print('error creating content index output file. aborting...');
		return None

def check_dir_exists(dirpath, create=False):
	d = pathlib.Path(dirpath)
	if d.is_dir():
		return d
	elif create:
		print(f"Directory {dirpath} is not a directory... Create it? [y/n]")
		x = input()
		if x.lower() == "y":
			d.mkdir(parents=True)
			return d
	return None



if __name__ == '__main__':

	p = argparse.ArgumentParser(description="SSSSTATIC generates html files from directory contents")
	p.add_argument('--input', "-i", help='input directory');
	p.add_argument('--output', "-o", help='output directory');
	p.add_argument('--style', "-y", default="+++", help='css style, ico, etc.');
	p.add_argument("--settings", "-s", default=".static/settings.json", help="Settings file (default: .static/settings.json")
	p.add_argument('--format', '-f', default="1000x1000", help='img output formats (ex. 1000x)');
	p.add_argument('--clean', help='cleans the output directory');

	args = p.parse_args();

	if args.settings == ".static/settings.json":
		file_settings = codebase / ".static/settings.json"
	else:
		file_settings = pathlib.Path(args.settings)

	if file_settings.exists() and file_settings.is_file():
		with file_settings.open(encoding="utf-8") as fp:
			settings = json.load(fp)
			input_dir = check_dir_exists(settings['inputdir'])
			output_dir = check_dir_exists(settings['outputdir'])
			style = settings['style']

	if args.input: 
		inputdir = check_dir_exists(args.input)
		if inputdir is not None:
			input_dir = inputdir;
		else:
			sys.exit(f"Input directory {args.input} is not a directory... Aborting.")

	if args.output: 
		outputdir = check_dir_exists(args.output, create=True)
		if outputdir is not None:
			output_dir = outputdir;
		else:
			sys.exit(f"Output directory {args.output} is not a directory... Aborting.")

	if args.format:
		(W, H, FMT) = utils.imgconv.parse_format(args.format)
		if not FMT:
			sys.exit(f"Format {str(args.format)} is not valid. Aborting.")		


	if style is not None:
		style_dir = codebase / f"styles/{style}"
		if not style_dir.is_dir():
			style = args.style			

	if input_dir is None:
		sys.exit(f"Error with input directory... Aborting.")

	if output_dir is None:
		print(f"No output directory.")
		print(f"Dry-run test? [y/n]")
		x = input()
		if x.lower() == "n":
			sys.exit(1)
	else:
		if output_dir.exists() and any(output_dir.iterdir()):
			print(f"? {output_dir} exists and is not empty. Erase content? [y/n]")
			x = input()
			if x.lower() == "y":
				try:
					shutil.rmtree(output_dir)						
				except:
					print(f"error erasing {output_dir}. Continuing.")

	print('1/3 - Configuring');	

	# main index template
	indx_template = codebase / "templates/index_template.html"
	with indx_template.open(encoding="utf-8") as fp:
		indx_template_str = fp.read()

	# images index template	
	section_indx_template = codebase / "templates/index_apache_template.html"
	with section_indx_template.open(encoding="utf-8") as fp:
		section_indx_template_str = fp.read()

	print('2/3 - Parsing input');

	dirs = sorted([d for d in input_dir.iterdir() if d.is_dir()])	

	content = ''
	for d in reversed(dirs):		
		indx_txt = d / 'index.txt'

		if not indx_txt.exists():
			print(f"{indx_txt} does not exists. Skipping.")
			continue

		with indx_txt.open(encoding="utf-8") as fp:
			txt = fp.read()

		dirname = escape_date(d.name)
		
		content += translate_index_header(txt, dirname);
		
		datadir = d / "data"
		if datadir.is_dir():
			section_indx_txt = datadir / "index.txt"
			section_desc_txt = datadir / "desc.md"

			out_index = None
			if section_indx_txt.is_file() or section_desc_txt.is_file():
				out_index = index_content(dirname, datadir, section_indx_txt, section_desc_txt, section_indx_template_str)

			if output_dir is not None:
				out_datadir = output_dir / dirname

				if out_datadir.exists() and any(out_datadir.iterdir()):
					print(f"		? {out_datadir} exists and is not empty. Erase content? [y/n]")
					x = input()
					if x.lower() == "y":
						try:
							shutil.rmtree(out_datadir)						
						except:
							print(f"error erasing {out_datadir}. Continuing.")

				try:
					shutil.copytree(datadir, out_datadir, ignore=shutil.ignore_patterns('.DS_Store'), dirs_exist_ok=True)
				except:
					print(f"error copying {datadir} to {out_datadir}. Continuing.")
					continue

				# copy index after (since index.html might be lurking in content dirs)
				if out_index:
					try:
						shutil.copy2(out_index, out_datadir)
					except:
						print(f"error copying {out_index} to {out_datadir}. Continuing.")
						continue

	print('3/3 - Generating ouput');

	html = indx_template_str.replace('[[content]]', content);

	if output_dir is not None:

		out = output_dir / "index.html"
		out.write_text(html, encoding="utf-8")

		# style
		style_dir = codebase / f"styles/{style}"
		if not style_dir.is_dir():
			print(f"{style} does not exists (make sure to add a style to styles/)... going vanilla")
		else:
			try:
				out_style_dir = output_dir / style
				shutil.copytree(style_dir, out_style_dir, ignore=shutil.ignore_patterns('.DS_Store'), dirs_exist_ok=True)
			except:
				print(f"error copying {style_dir} to {out_style_dir}. Continuing.")
		

		# robots.txt?
		robots = codebase / "templates/robots.txt"
		if robots.is_file():
			try:
				shutil.copy(robots, output_dir)
			except:
				print(f"error copying {robots} to {output_dir}. Continuing.")

		# .htaccess?
		ht = codebase / "templates/.htaccess"
		if ht.is_file():
			try:
				shutil.copy(ht, output_dir)
			except:
				print(f"error copying {ht} to {output_dir}. Continuing.")

	print('done.');