#!/usr/bin/env python
# IExTrading IRC Bot - Developed by acidvegas in Python (https://acid.vegas/iex)

import http.client
import json
import random
import ssl
import socket
import time

# Connection
server  = 'irc.supernets.org'
channel = '#dev'

# Identity
nickname = 'StockMarket'
username = 'iex'
realname = 'acid.vegas/iex'

# Login
nickserv_password = None
network_password  = None

# Settings
throttle_cmd = 3
throttle_msg = 0.5
user_modes   = None

# Formatting Control Characters / Color Codes
bold        = '\x02'
italic      = '\x1D'
underline   = '\x1F'
reverse     = '\x16'
reset       = '\x0f'
white       = '00'
black       = '01'
blue        = '02'
green       = '03'
red         = '04'
brown       = '05'
purple      = '06'
orange      = '07'
yellow      = '08'
light_green = '09'
cyan        = '10'
light_cyan  = '11'
light_blue  = '12'
pink        = '13'
grey        = '14'
light_grey  = '15'

def condense_value(value):
	value = float(value)
	if value < 0.01:
		return '${0:,.8f}'.format(value)
	elif value < 24.99:
		return '${0:,.2f}'.format(value)
	else:
		return '${:,}'.format(int(value))

def debug(msg):
	print(f'{get_time()} | [~] - {msg}')

def error(msg, reason=None):
	if reason:
		print(f'{get_time()} | [!] - {msg} ({reason})')
	else:
		print(f'{get_time()} | [!] - {msg}')

def error_exit(msg):
	raise SystemExit(f'{get_time()} | [!] - {msg}')

def get_float(data):
	try:
		float(data)
		return True
	except ValueError:
		return False

def get_time():
	return time.strftime('%I:%M:%S')

def percent_color(percent):
	percent = float(percent)
	if percent == 0.0:
		return grey
	elif percent < 0.0:
		if percent > -10.0:
			return brown
		else:
			return red
	else:
		if percent < 10.0:
			return green
		else:
			return light_green

def random_int(min, max):
	return random.randint(min, max)

class IEX:
	def api(api_data):
		conn = http.client.HTTPSConnection('api.iextrading.com', timeout=15)
		conn.request('GET', '/1.0/' + api_data)
		response = conn.getresponse().read().decode('utf-8')
		data = json.loads(response)
		conn.close()
		return data

	def company(symbol):
		return IEX.api(f'stock/{symbol}/company')

	def lists(list_type):
		return IEX.api('stock/market/list/' + list_type)

	def news(symbol):
		return IEX.api(f'stock/{symbol}/news')

	def quote(symbols):
		data = IEX.api(f'stock/market/batch?symbols={symbols}&types=quote')
		if len(data) == 1:
			return data[next(iter(data))]['quote']
		else:
			return [data[item]['quote'] for item in data]

	def stats(symbol):
		return IEX.api(f'stock/{symbol}/stats')

	def symbols():
		return IEX.api('ref-data/symbols')

class IRC(object):
	def __init__(self):
		self.last = 0
		self.slow = False
		self.sock = None

	def stock_info(self, data):
		sep      = self.color('|', grey)
		sep2     = self.color('/', grey)
		name     = '{0} ({1})'.format(self.color(data['companyName'], white), data['symbol'])
		value    = condense_value(data['latestPrice'])
		percent  = self.color('{:,.2f}%'.format(float(data['change'])), percent_color(data['change']))
		volume   = '{0} {1}'.format(self.color('Volume:', white), '${:,}'.format(data['avgTotalVolume']))
		cap      = '{0} {1}'.format(self.color('Market Cap:', white), '${:,}'.format(data['marketCap']))
		return f'{name} {sep} {value} ({percent}) {sep} {volume} {sep} {cap}'

	def stock_matrix(self, data): # very retarded way of calculating the longest strings per-column
		results = {'symbol':list(),'value':list(),'percent':list(),'volume':list(),'cap':list()}
		for item in data:
			results['symbol'].append(item['symbol'])
			results['value'].append(condense_value(item['latestPrice']))
			results['percent'].append('{:,.2f}%'.format(float(item['change'])))
			results['volume'].append('${:,}'.format(item['avgTotalVolume']))
			results['cap'].append('${:,}'.format(item['marketCap']))
		for item in results:
			results[item] = len(max(results[item], key=len))
		if results['symbol'] < len('Symbol'):
			results['symbol'] = len('Symbol')
		if results['value'] < len('Value'):
			results['value'] = len('Value')
		if results['percent'] < len('Change'):
			results['percent'] = len('Change')
		if results['volume'] < len('Volume'):
			results['volume'] = len('Volume')
		if results['cap'] < len('Market Cap'):
			results['cap'] = len('Market Cap')
		return results

	def stock_table(self, data):
		matrix = self.stock_matrix(data)
		header = self.color(' {0}   {1}   {2}   {3}   {4}'.format('Symbol'.center(matrix['symbol']), 'Value'.center(matrix['value']), 'Percent'.center(matrix['percent']),  'Volume'.center(matrix['volume']), 'Market Cap'.center(matrix['cap'])), black, light_grey)
		lines  = [header,]
		for item in data:
			symbol   = item['symbol'].ljust(matrix['symbol'])
			value    = condense_value(item['latestPrice']).rjust(matrix['value'])
			percent  = self.color('{:,.2f}%'.format(float(item['change'])).rjust(matrix['percent']), percent_color(item['change']))
			volume   = '${:,}'.format(item['avgTotalVolume']).rjust(matrix['volume'])
			cap      = '${:,}'.format(item['marketCap']).rjust(matrix['cap'])
			lines.append(' {0} | {1} | {2} | {3} | {4} '.format(symbol,value,percent,volume,cap))
		return lines

	def color(self, msg, foreground, background=None):
		if background:
			return f'\x03{foreground},{background}{msg}{reset}'
		else:
			return f'\x03{foreground}{msg}{reset}'

	def connect(self):
		try:
			self.sock = ssl.wrap_socket(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
			self.sock.connect((server, 6697))
			self.raw(f'USER {username} 0 * :{realname}')
			self.nick(nickname)
		except socket.error as ex:
			error('Failed to connect to IRC server.', ex)
			self.event_disconnect()
		else:
			self.listen()

	def error(self, chan, msg, reason=None):
		if reason:
			self.sendmsg(chan, '[{0}] {1} {2}'.format(self.color('!', red), msg, self.color('({0})'.format(reason), grey)))
		else:
			self.sendmsg(chan, '[{0}] {1}'.format(self.color('!', red), msg))

	def event_connect(self):
		if user_modes:
			self.mode(nickname, '+' + user_modes)
		if nickserv_password:
			self.identify(nickname, nickserv_password)
		self.join_channel(channel)

	def event_disconnect(self):
		self.sock.close()
		time.sleep(10)
		self.connect()

	def event_kick(self, chan, kicked):
		if chan == channel and kicked == nickname:
			time.sleep(3)
			self.join_channel(channel, key)

	def event_message(self, nick, chan, msg):
		#try:
			if msg[:1] in '@!':
				if time.time() - self.last < throttle_cmd:
					if not self.slow:
						self.error(chan, 'Slow down nerd!')
						self.slow = True
				else:
					args = msg.split()
					if msg == '@iex':
						self.sendmsg(chan, bold + 'IExTrading IRC Bot - Developed by acidvegas in Python - https://acid.vegas/iex')
					elif args[0] == '!stock':
						if len(args) == 2:
							symbols = args[1].upper()
							if ',' in symbols:
								symbols = ','.join(list(symbols.split(','))[:10])
								data    = IEX.quote(symbols)
								if type(data) == dict:
									self.sendmsg(chan, self.stock_info(data))
								elif type(data) == list:
									for line in self.stock_table(data):
										self.sendmsg(chan, line)
										time.sleep(throttle_msg)
								else:
									self.error(chan, 'Invalid stock names!')
							else:
								symbol = args[1]
								data = IEX.quote(symbol)
								if data:
									self.sendmsg(chan, self.stock_info(data))
								else:
									self.error(chan, 'Invalid stock name!')
						elif len(args) == 3:
							if args[1] == 'company':
								symbol = args[2]
								data = IEX.company(symbol)
								if data:
									self.sendmsg(chan, '{0} {1} ({2}) {3} {4} {5} {6} {7} {8}'.format(self.color('Company:', white), data['companyName'], data['symbol'], self.color('|', grey), data['website'], self.color('|', grey), data['industry'], self.color('|', grey), data['CEO']))
									self.sendmsg(chan, '{0} {1}'.format(self.color('Description:', white), data['description']))
								else:
									self.error('Invalid stock name!')
							elif args[1] == 'search':
								query = args[2].lower()
								data = [{'symbol':item['symbol'],'name':item['name']} for item in IEX.symbols() if query in item['name'].lower()]
								if data:
									count = 1
									max_length = len(max([item['name'] for item in data], key=len))
									for item in data[:10]:
										self.sendmsg(chan, '[{0}] {1} {2} {3}'.format(self.color(str(count), pink), item['name'].ljust(max_length), self.color('|', grey), item['symbol']))
										count += 1
										time.sleep(throttle_msg)
								else:
									self.error(chan, 'No results found.')
							elif args[1] == 'list':
								options = {'active':'mostactive','gainers':'gainers','losers':'losers','volume':'iexvolume','percent':'iexpercent'}
								option = args[2]
								try:
									option = options[option]
								except KeyError:
									self.error(chan, 'Invalid option!', 'Valid options are active, gainers, losers, volume, & percent')
								else:
									data = IEX.lists(option)
									for line in self.stock_table(data):
										self.sendmsg(chan, line)
										time.sleep(throttle_msg)
							elif args[1] == 'news':
								symbol = args[2]
								data   = IEX.news(symbol)
								if data:
									count  = 1
									for item in data:
										self.sendmsg(chan, '[{0}] {1}'.format(self.color(str(count), pink), item['headline']))
										self.sendmsg(chan, ' - ' + self.color(item['url'], grey))
										count += 1
										time.sleep(throttle_msg)
								else:
									self.error(chan, 'Invalid stock name!')
				self.last = time.time()
		#except Exception as ex:
		#	self.error(chan, 'Unknown error occured!', ex)

	def event_nick_in_use(self):
		self.nick('IEX_' + str(random_int(10,99)))

	def handle_events(self, data):
		args = data.split()
		if data.startswith('ERROR :Closing Link:'):
			raise Exception('Connection has closed.')
		elif args[0] == 'PING':
			self.raw('PONG ' + args[1][1:])
		elif args[1] == '001':
			self.event_connect()
		elif args[1] == '433':
			self.event_nick_in_use()
		elif args[1] == 'KICK':
			chan   = args[2]
			kicked = args[3]
			self.event_kick(nick, chan, kicked)
		elif args[1] == 'PRIVMSG':
			nick = args[0].split('!')[0][1:]
			chan = args[2]
			msg  = ' '.join(args[3:])[1:]
			if chan == channel:
				self.event_message(nick, chan, msg)

	def identify(self, nick, passwd):
		self.sendmsg('nickserv', f'identify {nick} {passwd}')

	def join_channel(self, chan, key=None):
		self.raw(f'JOIN {chan} {key}') if key else self.raw('JOIN ' + chan)

	def listen(self):
		while True:
			try:
				data = self.sock.recv(1024).decode('utf-8')
				for line in (line for line in data.split('\r\n') if line):
					debug(line)
					if len(line.split()) >= 2:
						self.handle_events(line)
			except (UnicodeDecodeError,UnicodeEncodeError):
				pass
			#except Exception as ex:
			#	error('Unexpected error occured.', ex)
			#	break
		self.event_disconnect()

	def mode(self, target, mode):
		self.raw(f'MODE {target} {mode}')

	def nick(self, nick):
		self.raw('NICK ' + nick)

	def raw(self, msg):
		self.sock.send(bytes(msg + '\r\n', 'utf-8'))

	def sendmsg(self, target, msg):
		self.raw(f'PRIVMSG {target} :{msg}')

IRC().connect()