import os
import json
import re
import psycopg2
import time
import socket
import datetime

"""Run parsing batch files"""
# if socket.gethostname() == "OP1":
# 	os.system('.\\createjsondata.bat')
# 	postgres_host ='127.0.0.1'
# else:
# 	os.system('.\\createjsondatatest.bat')
# 	postgres_host ='objectivelyperfect.com'

"""Establish Postgres Connection"""
def pgsql_connect():
	global conn, cur
	conn = psycopg2.connect(
	    database='your_database_name_here',
	    user='your_user_here',
	    password='your_password_here!',
	    host='127.0.0.1',
	    port='your_port')
	cur = conn.cursor()

def CreatureParse():
	class CreatureClass:
		x = None
		y = None
		z = None
		lat = None
		lon = None
		id = None
		female = None
		color0 = None
		color1 = None
		color2 = None
		color3 = None
		color4 = None
		color5 = None
		tamedAtTime = None
		tamedTime = None
		tribe = None
		tamer = None
		name = None
		baseLevel = None
		wildLevels_health = None
		wildLevels_stamina = None
		wildLevels_oxygen = None
		wildLevels_food = None
		wildLevels_weight = None
		wildLevels_melee = None
		wildLevels_speed = None
		fullLevel = None
		tamedLevels_health = None
		tamedLevels_stamina = None
		tamedLevels_oxygen = None
		tamedLevels_food = None
		tamedLevels_weight = None
		tamedLevels_melee = None
		tamedLevels_speed = None
		tamed = None
		imprinter = None
		experience = None
		imprintingQuality = None

	bypass_creatures = ['Ant_Character_BP_C',
						'Leech_Character_C',
						'FlyingAnt_Character_BP_C',
						'Coel_Character_BP_C',
						'Bat_Character_BP_C',
						'Piranha_Character_BP_C',
						'Salmon_Character_BP_C',
						'Trilobite_Character_C',
						'Dragonfly_Character_BP_C',
						'Euryp_Character_C',
						'BoaFrill_Character_BP_C'
						]

	files = os.listdir("./creatures")

	classes = json.load(open('./creatures/classes.json'))
	files.remove('classes.json')

	classdict = {}
	for item in classes:
	   name = item.pop('cls')
	   classdict[name] = item


	for file in files:
		path = './creatures/'+file
		if file[:-5] not in bypass_creatures:
			with open(path) as data_file:
			    creatures = json.load(data_file)
			print "Processing " + str(file)[:-5] + ":",
			for creature in creatures:
				critter = CreatureClass()
				try:
					critter.species = re.search(r'(.+?)_', file).group(1)
				except:
					critter.species = None

				for key in dir(critter):
					if "tamedLevels" in key:
						try:
							actual_key = key[12:]
							setattr(critter, key, creature[u'tamedLevels'][unicode(actual_key)])
						except:
							pass
					elif "wildLevels" in key:
						try:
							actual_key = key[11:]
							setattr(critter, key, creature[u'wildLevels'][unicode(actual_key)])
						except:
							pass
					elif key.startswith("__"):
						pass
					else:
						try:
							setattr(critter, key, creature[unicode(key)])
						except:
							pass

				cur.execute("""INSERT INTO creatures (
					runtime,
					species,
					x_coord,
					y_coord,
					z_coord,
					lat,
					lon,
					creature_id,
					female,
					color0,
					color1,
					color2,
					color3,
					color4,
					color5,
					tamedAtTime,
					tamedTime,
					tribe,
					tamer,
					name,
					baseLevel,
					wild_health,
					wild_stamina,
					wild_oxygen,
					wild_food,
					wild_weight,
					wild_melee,
					wild_speed,
					fullLevel,
					tamed_health,
					tamed_stamina,
					tamed_oxygen,
					tamed_food,
					tamed_weight,
					tamed_melee,
					tamed_speed,
					tamed,
					experience,
					imprinter,
					imprintingQuality) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);""", (
						runtime,
						classdict[file[:-5]]['name'],
						critter.x,
						critter.y,
						critter.z,
						critter.lat,
						critter.lon,
						critter.id,
						critter.female,
						critter.color0,
						critter.color1,
						critter.color2,
						critter.color3,
						critter.color4,
						critter.color5,
						critter.tamedAtTime,
						critter.tamedTime,
						critter.tribe,
						critter.tamer,
						critter.name,
						critter.baseLevel,
						critter.wildLevels_health,
						critter.wildLevels_stamina,
						critter.wildLevels_oxygen,
						critter.wildLevels_food,
						critter.wildLevels_weight,
						critter.wildLevels_melee,
						critter.wildLevels_speed,
						critter.fullLevel,
						critter.tamedLevels_health,
						critter.tamedLevels_stamina,
						critter.tamedLevels_oxygen,
						critter.tamedLevels_food,
						critter.tamedLevels_weight,
						critter.tamedLevels_melee,
						critter.tamedLevels_speed,
						critter.tamed,
						critter.experience,
						critter.imprinter,
						critter.imprintingQuality))
			print " Processed"
	conn.commit()

def TribeParse():
	class itemClass:
		name = None
		durability = None
		rating = None
		quality = None
		armorMultiplier = None
		durabilityMultiplier = None
		damageMultiplier = None
		quantity = 1
		hypoMultiplier = None
		hyperMultiplier = None
		customName = None
		customDescription = None

	files = os.listdir("./tribes")

	for file in files:
		path = './tribes/'+file

		with open(path) as data_file:
			tribe = json.load(data_file)
		print "Processing " + tribe['name'] + ": ",

		""" Upload Tribe Members/Admins data """
		admins = []
		try:
			admins = tribe['admins']
		except:
			pass

		for member in tribe['members']:
			admin = False
			owner = False
			if member in admins:
				admin = True
			if member == tribe['owner']:
				owner = True

			cur.execute("""INSERT INTO tribes (
				runtime,
				tribeId,
				Name,
				Members,
				Owner,
				Admins) VALUES (%s,%s,%s,%s,%s,%s);""", (
					runtime,
					file[:-5],
					tribe['name'],
					member,
					owner,
					admin))
		conn.commit()

		""" Upload Tribe Item Data """
		for item in tribe[u'items']:
			item_object = itemClass()
			for key in dir(item_object):
				try:
					setattr(item_object, key, item[unicode(key)])
				except:
					pass
			cur.execute("""INSERT INTO items (
				runtime,
				name,
				durability,
				rating,
				quality,
				armorMultiplier,
				durabilityMultiplier,
				damageMultiplier,
				quantity,
				hypoMultiplier,
				hyperMultiplier,
				customName,
				customDescription,
				tribeId) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);""", (
					runtime,
					item_object.name,
					item_object.durability,
					item_object.rating,
					item_object.quality,
					item_object.armorMultiplier,
					item_object.durabilityMultiplier,
					item_object.damageMultiplier,
					item_object.quantity,
					item_object.hypoMultiplier,
					item_object.hyperMultiplier,
					item_object.customName,
					item_object.customDescription,
					file[:-5]))
			conn.commit()

		for item in tribe[u'blueprints']:
			item_object = itemClass()
			for key in dir(item_object):
				try:
					setattr(item_object, key, item[unicode(key)])
				except:
					pass
			cur.execute("""INSERT INTO items (
				runtime,
				name,
				durability,
				rating,
				quality,
				durabilityMultiplier,
				damageMultiplier,
				quantity,
				hypoMultiplier,
				hyperMultiplier,
				customName,
				customDescription,
				blueprint,
				tribeId) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);""", (
					runtime,
					item_object.name,
					item_object.durability,
					item_object.rating,
					item_object.quality,
					item_object.durabilityMultiplier,
					item_object.damageMultiplier,
					item_object.quantity,
					item_object.hypoMultiplier,
					item_object.hyperMultiplier,
					item_object.customName,
					item_object.customDescription,
					True,
					file[:-5]))
			conn.commit()

		"""Upload Tribe Structure Data"""
		for structure in tribe[u'structures']:
			cur.execute("""INSERT INTO structures (
				runtime,
				tribeId,
				Name,
				Count) VALUES (%s,%s,%s,%s);""",(
					runtime,
					file[:-5],
					structure['name'],
					structure['count']))
		conn.commit()
		print "Processed"

def PlayerParse():
	class playerClass:
		engrams = None
		tribeName = None
		name = None
		level = None
		steamName = None
		tribeId = None
		experience = None
		inventory = None
		tribeOwner = None
		stat_melee = None
		stat_speed = None
		stat_health = None
		stat_weight = None
		stat_oxygen = None
		stat_stamina = None
		stat_fortitude = None
		stat_water = None
		stat_crafting = None
		stat_food = None
		player_id = None
		x = None
		y = None
		z = None
		lat = None
		lon = None

	files = os.listdir("./players")

	for file in files:
		path = './players/'+file

		with open(path) as data_file:
			playerjson = json.load(data_file)

		player = playerClass()

		print "Processsing " + playerjson['name'] + ": ",

		for key in dir(player):
			if "stat_" in key:
				try:
					actual_key = key[5:]
					setattr(player, key, playerjson['attributes'][unicode(actual_key)])
				except:
					pass
			elif key.startswith("__"):
				pass
			else:
				try:
					setattr(player, key, playerjson[unicode(key)])
				except:
					pass
		statbuf = os.stat(path)
		last_login = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(statbuf.st_mtime))

		""" Upload Player data """

		cur.execute("""INSERT INTO players (
			runtime,
			x_coord,
			y_coord,
			z_coord,
			lat,
			lon,
			tribe,
			player,
			level,
			tribeId,
			experience,
			tribeOwner,
			melee,
			speed,
			health,
			weight,
			oxygen,
			stamina,
			fortitude,
			water,
			crafting,
			food,
			player_id,
			last_login) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);""", (
				runtime,
				player.x,
				player.y,
				player.z,
				player.lat,
				player.lon,
				player.tribeName,
				player.name,
				player.level,
				player.tribeId,
				player.experience,
				player.tribeOwner,
				player.stat_melee,
				player.stat_speed,
				player.stat_health,
				player.stat_weight,
				player.stat_oxygen,
				player.stat_stamina,
				player.stat_fortitude,
				player.stat_water,
				player.stat_crafting,
				player.stat_food,
				file[:-5],
				last_login))
		conn.commit()

		""" Upload Player Item data """
		class itemClass:
			name = None
			durability = None
			rating = None
			quality = None
			armorMultiplier = None
			durabilityMultiplier = None
			damageMultiplier = None
			quantity = 1
			hypoMultiplier = None
			hyperMultiplier = None
			customName = None
			customDescription = None

		try:
			for item in player.inventory:
				item_object = itemClass()
				for key in dir(item_object):
					try:
						setattr(item_object, key, item[unicode(key)])
					except:
						pass
				cur.execute("""INSERT INTO items (
					runtime,
					name,
					durability,
					rating,
					quality,
					armorMultiplier,
					durabilityMultiplier,
					damageMultiplier,
					quantity,
					hypoMultiplier,
					hyperMultiplier,
					customName,
					customDescription,
					player_id) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);""", (
						runtime,
						item_object.name,
						item_object.durability,
						item_object.rating,
						item_object.quality,
						item_object.armorMultiplier,
						item_object.durabilityMultiplier,
						item_object.damageMultiplier,
						item_object.quantity,
						item_object.hypoMultiplier,
						item_object.hyperMultiplier,
						item_object.customName,
						item_object.customDescription,
						file[:-5]))
				conn.commit()
		except:
			pass
		""" Upload Player Engram data """

		print "Processed"
def main():
	global runtime
	print "Omni Initialized"

	runtime = datetime.datetime.now()
	pgsql_connect()
	os.system('.\\createjsondata.bat')
	CreatureParse()
	TribeParse()
	PlayerParse()
	cur.close()
	conn.close()

	path_to_watch = ".\ShooterGame\Saved\SavedArks\TheIsland.ark"

	before = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(os.stat(path_to_watch).st_mtime))
	while 1:
		time.sleep (10)
		after = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(os.stat(path_to_watch).st_mtime))
		if before != after:
			runtime = datetime.datetime.now()
			pgsql_connect()
			os.system('.\\createjsondata.bat')

			CreatureParse()
			TribeParse()
			PlayerParse()

			cur.close()
			conn.close()
			before = after

main()