import json
import time
import random
import re

MAX_LINE = 400


def ping(ircsock, msg):
    # print("{} => PONG {}".format(msg, msg.split(" ")[1]))
    ircsock.send("PONG {}\n".format(msg.split(" ")[1]).encode())


def sendmsg(ircsock, chan, msg):
    print("sending {} to {}".format(msg, chan)[0:MAX_LINE])
    ircsock.send("PRIVMSG {} :{}\r\n".format(chan, msg).encode()[0:MAX_LINE])

def notice(ircsock, user, chan, msg):
    print("sending notice {} to {} in {}".format(msg, user, chan)[0:MAX_LINE])
    ircsock.send("CNOTICE {} {} :{}\r\n".format(user, chan, msg).encode()[0:MAX_LINE])

def part(ircsock, chan, msg="Bye!"):
    print("leaving channel {}".format(chan))
    ircsock.send("PART {} {}\r\n".format(chan, msg).encode())

def quit(ircsock, msg="Quitting!"):
    print("!! quitting !!")
    ircsock.send("QUIT {}".format(msg).encode())

def joinchan(ircsock, chan):
    print("joining {}".format(chan))
    ircsock.send("JOIN {}\r\n".format(chan).encode())


def get_user_from_message(msg):
    try:
        i1 = msg.index(":") + 1
        i2 = msg.index("!")
        return msg[i1:i2]
    except ValueError:
        return ""


def connect(ircsock, options):
    print(options)
    server, port = options.server.split(":")
    ircsock.connect((server, int(port)))
    print(ircsock)
    nick = "NICK {}\r\n".format(options.nick).encode()
    print(nick)
    ircsock.send(nick)
    login = "USER {0} {0} {0} {0}".format(options.nick).encode()
    print(login)
    ircsock.send(login)
    mode = "MODE +B {}\r\n".format(options.nick).encode()
    print(mode)
    ircsock.send(mode)
    if 'channels' in options:
        for channel in options.channels:
            joinchan(ircsock, channel)
    else:
        joinchan(ircsock, options.channel)


# integer number to english word conversion
# can be used for numbers as large as 999 vigintillion
# (vigintillion --> 10 to the power 60)
# tested with Python24      vegaseat      07dec2006
def int2word(n):
    """
    convert an integer number n into a string of english words
    """
    # break the number into groups of 3 digits using slicing
    # each group representing hundred, thousand, million, billion, ...
    n3 = []
    r1 = ""
    # create numeric string
    ns = str(n)
    for k in range(3, 33, 3):
        r = ns[-k:]
        q = len(ns) - k
        # break if end of ns has been reached
        if q < -2:
            break
        else:
            if q >= 0:
                n3.append(int(r[:3]))
            elif q >= -1:
                n3.append(int(r[:2]))
            elif q >= -2:
                n3.append(int(r[:1]))
        r1 = r

    # print n3  # test

    # break each group of 3 digits into
    # ones, tens/twenties, hundreds
    # and form a string
    nw = ""
    for i, x in enumerate(n3):
        b1 = x % 10
        b2 = (x % 100) // 10
        b3 = (x % 1000) // 100
        # print b1, b2, b3  # test
        if x == 0:
            continue  # skip
        else:
            t = thousands[i]
        if b2 == 0:
            nw = ones[b1] + t + nw
        elif b2 == 1:
            nw = tens[b1] + t + nw
        elif b2 > 1:
            nw = twenties[b2] + ones[b1] + t + nw
        if b3 > 0:
            nw = ones[b3] + "hundred " + nw
    return nw


############# globals ################
ones = [
    "",
    "one ",
    "two ",
    "three ",
    "four ",
    "five ",
    "six ",
    "seven ",
    "eight ",
    "nine ",
]
tens = [
    "ten ",
    "eleven ",
    "twelve ",
    "thirteen ",
    "fourteen ",
    "fifteen ",
    "sixteen ",
    "seventeen ",
    "eighteen ",
    "nineteen ",
]
twenties = [
    "",
    "",
    "twenty ",
    "thirty ",
    "forty ",
    "fifty ",
    "sixty ",
    "seventy ",
    "eighty ",
    "ninety ",
]
thousands = [
    "",
    "thousand ",
    "million ",
    "billion ",
    "trillion ",
    "quadrillion ",
    "quintillion ",
    "sextillion ",
    "septillion ",
    "octillion ",
    "nonillion ",
    "decillion ",
    "undecillion ",
    "duodecillion ",
    "tredecillion ",
    "quattuordecillion ",
    "sexdecillion ",
    "septendecillion ",
    "octodecillion ",
    "novemdecillion ",
    "vigintillion ",
]


def format_message(message):
    pattern = r"^:.*\!~(.*)@.* (.*) (.*) :(.*)"
    now = int(time.time())
    matches = re.match(pattern, message)
    if not matches:
        return ""

    nick = matches.group(1).strip()
    command = matches.group(2).strip()
    channel = matches.group(3).strip()
    message = matches.group(4).strip()

    return "%s\t%s\t%s\t%s\t%s" % (now, nick, command, channel, message)


def get_users():
    # thanks, ~dan!
    users = []
    with open("/etc/passwd", "r") as f:
        for line in f:
            if "/bin/bash" in line:
                u = line.split(":")[0]  # Grab all text before first ':'
                users.append(u)

    return users


def get_name(name):
    names_file = "/home/jumblesale/Code/canonical_names/canonical_names.json"
    try:
        with open(names_file) as names_data:
            names = json.load(names_data)
            try:
                return names[name]["userName"]
            except KeyError:
                return name
    except IOError:
        return name  # if we didn't already


def pretty_date(time=False):
    """
  Get a datetime object or a int() Epoch timestamp and return a
  pretty string like 'an hour ago', 'Yesterday', '3 months ago',
  'just now', etc
  """
    from datetime import datetime

    now = datetime.now()
    if type(time) is int:
        diff = now - datetime.fromtimestamp(time)
    elif isinstance(time, datetime):
        diff = now - time
    elif not time:
        diff = now - now
    second_diff = diff.seconds
    day_diff = diff.days

    if day_diff < 0:
        return ""

    if day_diff == 0:
        if second_diff < 10:
            return "just now"
        if second_diff < 60:
            return str(second_diff) + " seconds ago"
        if second_diff < 120:
            return "a minute ago"
        if second_diff < 3600:
            return str(second_diff / 60) + " minutes ago"
        if second_diff < 7200:
            return "an hour ago"
        if second_diff < 86400:
            return str(second_diff / 3600) + " hours ago"
    if day_diff == 1:
        return "Yesterday"
    if day_diff < 7:
        return str(day_diff) + " days ago"
    if day_diff < 31:
        return str(day_diff / 7) + " weeks ago"
    if day_diff < 365:
        return str(day_diff / 30) + " months ago"
    return str(day_diff / 365) + " years ago"


def makeRainbow(word):

    word = word or "RAINBOW"
    output = ""
    rb = ["5", "7", "8", "3", "12", "13", "6"]
    bg = "01"
    idx = random.randrange(0, len(rb))

    for l in word:
        if l == " ":
            output += " "
        else:
            output += "\x03" + rb[idx % len(rb)] + "," + bg + l
            idx += 1

    return output