﻿import re

from .BCalcWrapper import BCalcWrapper
from .Exceptions import FieldNotFoundException, DDTableInvalidException


class PBNField(object):

    def __init__(self, key=None, value=None, raw_data=None):
        self.key = key
        self.value = value
        self.raw_field = '[%s "%s"]' % (self.key, str(self.value)) \
                         if self.key is not None else raw_data

class PBNBoard(object):

    line_pattern = re.compile(r'\[(.*) "(.*)"\]')
    ability_pattern = re.compile(r'\b([NESW]):([0-9A-D]{5})\b')
    optimum_result_table_pattern = re.compile(
        r'^([NESW])\s+([CDHSN])T?\s+(\d+)$')

    def __init__(self, lines):
        self._has_optimum_result_table = None
        self._has_ability = None
        self.fields = []
        for line in lines:
            field = PBNField(raw_data=line)
            line_parse = self.line_pattern.match(line)
            if line_parse:
                field.key = line_parse.group(1)
                field.value = line_parse.group(2)
            self.fields.append(field)

    def has_field(self, key):
        for field in self.fields:
            if key == field.key:
                return True
        return False

    def get_field(self, key):
        for field in self.fields:
            if key == field.key:
                return field.value
        raise FieldNotFoundException(key + ' field not found')

    def delete_field(self, key):
        to_remove = []
        for field in self.fields:
            if key == field.key:
                to_remove.append(field)
        for remove in to_remove:
            self.fields.remove(remove)

    def get_event(self):
        return self.get_field('Event')

    def write_event(self, name):
        for i in range(0, len(self.fields)):
            if 'Board' == self.fields[i].key:
                self.fields.insert(i, PBNField(key='Event', value=name))
                break

    def get_layout(self):
        return self.get_field('Deal')

    def get_number(self):
        return self.get_field('Board')

    def get_vulnerable(self):
        return self.get_field('Vulnerable')

    def get_dealer(self):
        return self.get_field('Dealer')

    def validate_ability(self, ability):
        matches = self.ability_pattern.findall(ability)
        if not len(matches):
            self._has_ability = False
            raise DDTableInvalidException('Invalid Ability line: ' + ability)
        players = []
        for match in matches:
            if match[0] in players:
                self._has_ability = False
                raise DDTableInvalidException(
                    'Duplicate entry in Ability: ' + match[0])
            else:
                players.append(match[1])
        self._has_ability = False
        return matches

    def get_ability(self):
        return self.get_field('Ability')

    def delete_ability(self):
        self.delete_field('Ability')

    def write_ability(self, dd_table):
        sb = ''
        for i in range(0, 4):
            sb += BCalcWrapper.PLAYERS[i]
            sb += ':'
            sb += ''.join(['%X' % (j) for j in dd_table[i]])[::-1]
            sb += ' '
        self.fields.append(PBNField(key='Ability', value=sb.strip()))

    def get_minimax(self):
        return self.get_field('Minimax')

    def delete_minimax(self):
        self.delete_field('Minimax')

    def write_minimax(self, contract):
        minimax = '7NS0' if contract.score == 0 \
                  else '%d%s%s%s%d' % (
                          contract.level,
                          contract.denomination,
                          'D' if contract.doubled else '',
                          contract.declarer,
                          contract.score)
        self.fields.append(PBNField(key='Minimax', value=minimax))

    def get_optimum_score(self):
        return self.get_field('OptimumScore')

    def delete_optimum_score(self):
        self.delete_field('OptimumScore')

    def write_optimum_score(self, contract):
        self.fields.append(
            PBNField(key='OptimumScore',
                     value='NS %d' % (contract.score)))

    def get_optimum_result(self):
        return self.get_field('OptimumResult')

    def validate_optimum_result_table(self, table):
        matches = []
        duplicates = []
        for line in table:
            match = self.optimum_result_table_pattern.match(line)
            if not match:
                self._has_optimum_result_table = False
                raise DDTableInvalidException(
                    'Invalid OptimumResultTable line: ' + line)
            position = match.group(1) + ' - ' + match.group(2)
            if position in duplicates:
                self._has_optimum_result_table = False
                raise DDTableInvalidException(
                    'Duplicate OptimumResultTable line: ' + line)
            else:
                duplicates.append(position)
            matches.append(match)
        self._has_optimum_result_table = True
        return matches

    def get_optimum_result_table(self):
        field_found = False
        result = []
        for field in self.fields:
            if 'OptimumResultTable' == field.key:
                field_found = True
            else:
                if field_found:
                    if field.key is None:
                        result.append(field.raw_field)
                    else:
                        break
        if not field_found:
            self._has_optimum_result_table = False
            raise FieldNotFoundException('OptimumResultTable field not found')
        return result

    def delete_optimum_result_table(self):
        field_found = False
        to_remove = []
        for field in self.fields:
            if 'OptimumResultTable' == field.key:
                field_found = True
                to_remove.append(field)
            else:
                if field_found:
                    if field.key is None:
                        to_remove.append(field)
                    else:
                        break
        for remove in to_remove:
            self.fields.remove(remove)

    def write_optimum_result_table(self, dd_table):
        self.fields.append(PBNField(
            key='OptimumResultTable',
            value=r'Declarer;Denomination\2R;Result\2R'))
        for i in range(0, 4):
            for j in range(0, 5):
                self.fields.append(PBNField(
                    raw_data='%s %s%s %d' % (
                        BCalcWrapper.PLAYERS[i],
                        BCalcWrapper.DENOMINATIONS[j],
                        'T' if BCalcWrapper.DENOMINATIONS[j] == 'N' else '',
                        dd_table[i][j])))

    def save_par_contract(self, contract, jfr_only=False):
        if not jfr_only:
            self.delete_optimum_score()
            self.write_optimum_score(contract)
        self.delete_minimax()
        self.write_minimax(contract)

    def save_dd_table(self, dd_table, jfr_only=False):
        if not jfr_only:
            if self._has_optimum_result_table is None:
                try:
                    optimum_result_table = self.validate_optimum_result_table(
                        self.get_optimum_result_table())
                    self._has_optimum_result_table = True
                except FieldNotFoundException:
                    self._has_optimum_result_table = False
            if not self._has_optimum_result_table:
                self.delete_optimum_result_table()
                self.write_optimum_result_table(dd_table)
        if self._has_ability is None:
            try:
                ability = self.validate_ability(
                    self.get_ability())
                self._has_ability = True
            except FieldNotFoundException:
                self._has_ability = False
        if not self._has_ability:
            self.delete_ability()
            self.write_ability(dd_table)
