import sys
sys.path.insert(0, "/var/www/apps/virtualenv1/lib/python2.7/site-packages")
from flask import Flask, request, render_template
from flask_restful import Resource, Api
from flask_httpauth import HTTPBasicAuth
from bs4 import BeautifulSoup
import logging.handlers
import os
import requests
import base64
import glob
import binascii
import time
from datetime import datetime
import urllib

###########################################
# Local app settings
try:
	import settings as cfg
except: pass

try:
	user_database = cfg.user_database
except:
	user_database = "users.xml"
try:
	log_location = cfg.log_location
except:
	log_location = "beta"
try:
	app_debug = cfg.app_debug
except:
	app_debug = False
try:
	data_location = cfg.data_location
except:
	data_location = "data"



app_version = "0.4.3-beta"

app = Flask(__name__)
api = Api(app)

auth = HTTPBasicAuth()
users = {
    "x5tr34m": "eGu4gr8B"
}

@auth.get_password
def get_pw(username):
	if username in users:
		return users.get(username)
	return None

def get_logdata(fname):
	data = []
	with open(fname) as f:
		for i, l in enumerate(f):
			info = l.strip()[len("2017-09-15 15:15:02 INFO: "):].split("[*]")
			user_data = {}
			user_data["time"] = l.strip()[:len("2017-09-15 15:15:02")]
			for i in info:
				key = i[:i.find("=")]
				value = i[i.find("=")+1:]
				user_data[key] = value
			data.append(user_data)
		return data

def getRemainingDays(subcription_date):
	try:
		subscription_date = datetime.strptime(subcription_date, '%Y-%m-%d').date()
	except TypeError:
		subscription_date = datetime(*(time.strptime(subcription_date, '%Y-%m-%d')[0:6])).date()
	days_remaining = (subscription_date - datetime.now().date()).days
	return days_remaining

@app.route('/user_stats')
@auth.login_required
def user_stats():
	requested_log_file = "" if not "log_file" in request.args else urllib.unquote_plus(request.args["log_file"])

	if requested_log_file != "":
		user_data = get_logdata(os.path.join(log_location, "user_logs", requested_log_file))
		user_name, host_id = os.path.basename(requested_log_file)[:-len(".log")].split("#")
		return render_template('logfile.html', result=user_data, username=user_name)

	users_data = {}
	user_database = getUserDatabase()
	for user_log_file in glob.glob(os.path.join(log_location, "user_logs", "*.log")):
		try:
			user_name, host_id = os.path.basename(user_log_file)[:-len(".log")].split("#")
			if not user_name in user_database:
				os.remove(user_log_file)
				continue

			host_id = base64.b64decode(binascii.a2b_hex(host_id))
			cdate, hostname = host_id.split("$")
			cdate = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(int(cdate)))
			user_data = get_logdata(user_log_file)
			actions = len(user_data)

			if not user_name in users_data:
				users_data[user_name] = {}

			if not host_id in users_data[user_name]:
				users_data[user_name][host_id] = {}

			users_data[user_name][host_id]["logfile"] = urllib.quote_plus(os.path.basename(user_log_file))
			users_data[user_name][host_id]["hostname"] = hostname
			users_data[user_name][host_id]["creation_date"] = cdate
			users_data[user_name][host_id]["actions"] = actions
			users_data[user_name][host_id]["expiration"] = user_database[user_name]["subscription"]
			users_data[user_name][host_id]["remaining_days"] = getRemainingDays(user_database[user_name]["subscription"])

			for key, value in user_data[-1].iteritems():
				users_data[user_name][host_id][key] = value
		except: pass
	return render_template('users.html', result=users_data)

## Server logs
if not os.path.exists(os.path.join(log_location, "server_logs")):
	os.makedirs(os.path.join(log_location, "server_logs"))

server_log = logging.getLogger('werkzeug')
server_log.setLevel(logging.INFO)
fh = logging.handlers.TimedRotatingFileHandler(filename=os.path.join(log_location, "server_logs", "beta.log"), backupCount=182, when='midnight')
fh.setLevel(logging.INFO)
formatter = logging.Formatter(fmt='%(asctime)s v{0} %(levelname)s: %(message)s'.format(app_version), datefmt='%Y-%m-%d %H:%M:%S')
fh.setFormatter(formatter)
server_log.addHandler(fh)

def output_data(data, content, guide_data):
	output = {}
	output["content"] = content
	output["guide_data"] = guide_data
	output["subscription"] = data["subscription"]
	return output

def open_logfile(log_file):
	logging.getLogger().setLevel(logging.INFO)
	fh = logging.FileHandler(filename=log_file)
	fh.setLevel(logging.INFO)
	formatter = logging.Formatter(fmt='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
	fh.setFormatter(formatter)
	logging.getLogger().addHandler(fh)
	return logging.getLogger(), fh

def close_logfile(log, fh):
	log.removeHandler(fh)

def getGuideData(req_filename):
	guide_data = ""
	guide_file_path = os.path.join(data_location, "guide_data", req_filename + ".json")
	if os.path.exists(guide_file_path):
		with open(guide_file_path,"r") as f:
			guide_data = f.read()
	return guide_data

def getXmlData(uri):
	data = ""
	uri = uri.encode('utf-8', 'ignore')
	try:
		if uri.lower().startswith("http"):
			data = requests.get(uri).content
		else:
			xml_file_path = os.path.join(data_location, uri)
			if os.path.exists(xml_file_path):
				with open(xml_file_path , 'r') as f:
					data = f.read()
	except: pass

	return data

def getUserDatabase():
	if user_database.lower().startswith("http"):
		page = requests.get(user_database)
		soup = BeautifulSoup(page.content, "html.parser")
	else:
		soup = BeautifulSoup(open(user_database,"r").read(), "html.parser")

	user_data = {}
	for user in soup("user"):
		user_attributes = {}
		for att in user.attrs:
			if not att.lower() == "username":
				user_attributes[att] = user[att]
		user_data[user["username"]] = user_attributes
	return user_data

class Validator(Resource):
	def __init__(self):
		super(Resource, self).__init__()

	def get(self):
		server_log.info(request)

		# Grab arguments
		remote_user = "" if not "username" in request.args else request.args["username"]
		remote_password = "" if not "password" in request.args else request.args["password"]
		remote_uuid = "None" if not "uuid" in request.args else request.args["uuid"]
		remote_url = "None" if not "url" in request.args else request.args["url"]
		addon_version = "None" if not "addon_version" in request.args else request.args["addon_version"]
		kodi_version = "None" if not "kodi_version" in request.args else request.args["kodi_version"]
		os_name = "None" if not "os" in request.args else request.args["os"]

		if remote_user and remote_password:
			user_database = getUserDatabase()
			if remote_user in user_database:
				user_data = user_database[remote_user]
				if user_data["password"] == remote_password:
					days_remaining = getRemainingDays(user_data["subscription"])
					if days_remaining < 0:
						return user_data["subscription"], 402

					if not os.path.exists(os.path.join(log_location, "user_logs")):
						os.makedirs(os.path.join(log_location, "user_logs"))

					user_log_path = os.path.join(log_location, "user_logs", "{0}#{1}.log".format(remote_user, remote_uuid))
					user_log, fh = open_logfile(user_log_path)
					user_log.info('ip={1}{0}addon_version={2}{0}url={3}{0}os={4}{0}kodi_version={5}'.format("[*]", request.environ["REMOTE_ADDR"], addon_version, remote_url.encode('utf-8', 'ignore'), os_name, kodi_version))
					close_logfile(user_log, fh)

					content = ""
					guide_data = ""
					requested_xml = ""
					if remote_url.lower() == "home":
						requested_xml = user_data["home"]
					elif remote_url.lower().endswith(".xml"):
						requested_xml = remote_url

					if requested_xml:
						content = base64.b64encode(getXmlData(requested_xml))
						guide_data = getGuideData(requested_xml.rsplit('/', 1)[-1])

					return output_data(user_data, content, guide_data), 202

		# Invalid user
		server_log.warning("Connection REFUSED")
		return "invalid user", 401

api.add_resource(Validator, '/validator')

if __name__ == '__main__':
	# Production
	app.run(debug=app_debug, port=52481, host='0.0.0.0')