from enum import Enum
import re
import datetime
import logging

re_trade = re.compile(
    r'Hi, I would like to buy your (?P<item>.+) listed for (?P<amount>\d+) (?P<currency>\S+) in (?P<league>\S+) '
    r'\(stash tab "(?P<tab>.+)"; position: left (?P<col>\d+), top (?P<row>\d+)\)'
)
re_log = re.compile(
    r'(?P<date>\d\d\d\d/\d\d/\d\d \d\d:\d\d:\d\d) (\d+) (\S+) \[(?P<level>\S+) (\S+) (\d+)\] '
    r'(?P<channel>[#@%$&]?)(?P<ToFrom>To|From)?\s?(?P<guild><\S+>)? ?(?P<user>[^:]+): (?P<message>.*)'
)
log = logging.getLogger(__name__)
logging.basicConfig(level=logging.DEBUG, format='%(levelname)-8s:: %(message)s')


def compile_regex(conf: dict):
    global re_trade, re_log
    if 'General' in conf:
        if 're_log' in conf['Parser']:
            re_log = re.compile(conf['Parser']['re_log'])
        if 're_trade' in conf['Parser']:
            re_trade = re.compile(conf['Parser']['re_trade'])


class Channel(Enum):
    WHISPER = 0
    GLOBAL = 1
    PARTY = 2
    LOCAL = 3
    TRADE = 4
    GUILD = 5


channel_mapping = {'#': Channel.GLOBAL,
                   '@': Channel.WHISPER,
                   '%': Channel.PARTY,
                   '': Channel.LOCAL,
                   '$': Channel.TRADE,
                   '&': Channel.GUILD}


class Trade():
    def __init__(self,
                 nrItems: str,
                 item: str,
                 amount: int,
                 currency: str,
                 tab: str,
                 row: str,
                 col: str,
                 league: str) -> None:
        self.nrItems = int(nrItems) if nrItems else None
        self.item = item
        self.amount = amount
        self.currency = currency
        self.tab = tab
        self.row = int(row) if row else None
        self.col = int(col) if col else None
        self.league = league

    def __str__(self) -> str:
        return f'Trade: {self.nrItems} {self.item} for {self.amount} {self.currency} in {self.tab} ({self.row}/{self.col}) in {self.league} league'


class Message():
    def __init__(self,
                 message: str,
                 date: datetime.datetime,
                 user: str,
                 channel: Channel,
                 guild: str = None,
                 to_from: str = None) -> None:
        self.message = message
        self.date = date
        self.channel = channel
        self.user = user
        self.guild = guild
        self.to_from = to_from
        self.trade = None
        if self.channel is Channel.WHISPER:
            self.parse_trade()

    @classmethod
    def from_text(cls, text: str):
        result = re_log.search(text)
        if not result:
            log.debug(f'Result is none for text "{text}"')
            return None
        date = datetime.datetime.strptime(
            result.group('date'), '%Y/%m/%d %H:%M:%S')
        guild = result.group('guild')
        if guild:
            guild = guild.strip('<>')
        return cls(result.group('message'),
                   date,
                   result.group('user'),
                   channel_mapping[result.group('channel')],
                   guild,
                   result.group('ToFrom'))

    def __str__(self) -> str:
        text = f'Message: {self.date} - {self.channel.name}: '
        if self.to_from:
            text = text + f'{self.to_from} '
        if self.guild:
            text = text + f'<{self.guild}> '
        text = text + f'{self.user}: {self.message}'
        return text

    def parse_trade(self) -> None:
        res = re_trade.search(self.message)
        if res:
            self.trade = Trade(nrItems=res['nrItems'],
                               item=res['item'],
                               amount=int(res['amount']),
                               currency=res['currency'],
                               tab=res['tab'],
                               row=res['row'],
                               col=res['col'],
                               league=res['league'])