#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Crawlers and Scrapers for retrieving data/tables from URLs."""
from __future__ import division, print_function, absolute_import

import os
# import urllib2

# from bs4 import BeautifulSoup

from pug.nlp.regex_patterns import email_popular
from pug.nlp.constant import DATA_PATH


def find_emails(html=os.path.join(DATA_PATH, 'Locations.html')):
    """Extract email addresses from an html page or ASCII stream."""
    if isinstance(html, (str, bytes)):
        if os.path.isfile(html):
            html = open(html, 'r').read()
        html = email_popular.findall(html)
    return [x[0] for x in html]


# #!/usr/local/bin/python
# # coding: UTF-8
# # modified code downloaded from:
# # http://devwiki.beloblotskiy.com/index.php5/Generic_HTML_Table_parser_(python)
# # mods by: Aquil H. Abdullah
# from HTMLParser import HTMLParser
# # import pdb

# # Print debug info
# markup_debug_low = not True
# markup_debug_med = not True


# class NestedTableError(Exception):

#     """
#     Error raised when TableParser finds a nested table.
#     """

#     def __init__(self, msg):
#         self.msg = msg

#     def __str__(self):
#         return repr(self.msg)

# # Generic HTML table parser


# class TableParser(HTMLParser):

#     """
#     Class to handle extracting a table from an HTML Page.
#     NOTE: Does not handle Tables within
#     """

#     def __init__(self):
#         HTMLParser.__init__(self)
#         # Can't use super HTMLParser is an old-style class
#         # super(TableParser, self).__init__()
#         self._tables = list()  # Added to generic class
#         self._curr_table = list()  # Added to generic class
#         self._curr_row = list()  # Added to generic class
#         self._curr_cell = ''  # Added to generic class
#         self._in_table = False  # Added to generic class
#         self._td_cnt = 0
#         self._tr_cnt = 0
#         self._curr_tag = ''
#         self._colspan = 1

#     def get_tables(self):
#         """
#         Return the list of tables scraped from html page
#         """
#         return self._tables

#     def handle_starttag(self, tag, attrs):
#         self._curr_tag = tag
#         if tag.upper() == 'TABLE' and not self._in_table:
#             self._in_table = True
#         elif tag.upper() == 'TABLE' and self._in_table:
#             raise NestedTableError("Parsing Failed Nested Table Found.")

#         if tag == 'td':
#             self._td_cnt += 1
#             for attr in attrs:
#                 if attr[0].upper() == 'COLSPAN':
#                     self._colspan = int(attr[1])
#             self.col_start(self._td_cnt)
#             if markup_debug_low:
#                 print "<TD> --- %s ---" % self._td_cnt
#         elif tag == 'tr':
#             self._td_cnt = 0
#             self._tr_cnt += 1
#             self.row_start(self._tr_cnt)
#             if markup_debug_low:
#                 print "<TR> === %s ===" % self._tr_cnt
#         else:
#             if markup_debug_low:
#                 print "<%s>" % tag

#     def handle_endtag(self, tag):
#         if tag.upper() == 'TABLE':
#             self._in_table = False
#             self._tables.append(self._curr_table)
#             self._curr_table = list()
#         if markup_debug_low:
#             print "</%s>" % tag
#         # it's possible to check "start tag - end tag" pair here (see, tag and self._curr_tag)
#         if tag == 'tr':
#             self.row_finish(self._tr_cnt)
#         elif tag == 'td':
#             self.col_finish(self._td_cnt)
#             self._colspan = 1
#         else:
#             pass

#     def handle_data(self, data):
#         # if markup_debug_low: print u'[%s,%s] %s: "%s"' % (self._tr_cnt, self._td_cnt, self._curr_tag, unicode(data, 'mbcs'))
#         self.process_raw_data(self._tr_cnt, self._td_cnt, self._curr_tag, data)

#     # Overridable
#     def process_raw_data(self, row, col, tag, data):
#         if row > 0 and col > 0:
#             self.process_cell_data(row, col, tag, data)
#         else:
#             pass    # outside the table

#     # Overridable
#     def process_cell_data(self, row, col, tag, data):
#         # pass
#         self._curr_cell += data.strip() + ' '

#     # Overridable
#     def row_start(self, row):
#         # pass
#         self._curr_row = list()

#     # Overridable
#     def row_finish(self, row):
#         # pass
#         row = self._curr_row[:]
#         self._curr_table.append(row)

#     # Overridable
#     def col_start(self, col):
#         # pass
#         self._curr_cell = ''

#     # Overridable
#     def col_finish(self, col):
#         # pass
#         self._curr_row.append(self._curr_cell)
#         pad = self._colspan - 1
#         if pad > 0:
#             for i in range(pad):
#                 self._curr_row.append('')
