import asyncio
import string
from collections import Counter
from itertools import count, tee

import cv2
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import streamlit as st
import torch
from PIL import Image
from transformers import (DetrImageProcessor,
                          TableTransformerForObjectDetection)
from vietocr.tool.config import Cfg
from vietocr.tool.predictor import Predictor

st.set_option('deprecation.showPyplotGlobalUse', False)
st.set_page_config(layout='wide')
st.title("Table Detection and Table Structure Recognition")
st.write(
    "Implemented by MSFT team: https://github.com/microsoft/table-transformer")

# config = Cfg.load_config_from_name('vgg_transformer')
config = Cfg.load_config_from_name('vgg_seq2seq')
config['cnn']['pretrained'] = False
config['device'] = 'cpu'
config['predictor']['beamsearch'] = False
detector = Predictor(config)

table_detection_model = TableTransformerForObjectDetection.from_pretrained(
    "microsoft/table-transformer-detection")

table_recognition_model = TableTransformerForObjectDetection.from_pretrained(
    "microsoft/table-transformer-structure-recognition")


def PIL_to_cv(pil_img):
    return cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)


def cv_to_PIL(cv_img):
    return Image.fromarray(cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB))


async def pytess(cell_pil_img, threshold: float = 0.5):
    text, prob = detector.predict(cell_pil_img, return_prob=True)
    st.write(prob)
    if prob < threshold:
        return ""
    return text.strip()


def sharpen_image(pil_img):

    img = PIL_to_cv(pil_img)
    sharpen_kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])

    sharpen = cv2.filter2D(img, -1, sharpen_kernel)
    pil_img = cv_to_PIL(sharpen)
    return pil_img


def uniquify(seq, suffs=count(1)):
    """Make all the items unique by adding a suffix (1, 2, etc).
    Credit: https://stackoverflow.com/questions/30650474/python-rename-duplicates-in-list-with-progressive-numbers-without-sorting-list
    `seq` is mutable sequence of strings.
    `suffs` is an optional alternative suffix iterable.
    """
    not_unique = [k for k, v in Counter(seq).items() if v > 1]

    suff_gens = dict(zip(not_unique, tee(suffs, len(not_unique))))
    for idx, s in enumerate(seq):
        try:
            suffix = str(next(suff_gens[s]))
        except KeyError:
            continue
        else:
            seq[idx] += suffix

    return seq


def binarizeBlur_image(pil_img):
    image = PIL_to_cv(pil_img)
    thresh = cv2.threshold(image, 150, 255, cv2.THRESH_BINARY_INV)[1]

    result = cv2.GaussianBlur(thresh, (5, 5), 0)
    result = 255 - result
    return cv_to_PIL(result)


def td_postprocess(pil_img):
    '''
    Removes gray background from tables
    '''
    img = PIL_to_cv(pil_img)

    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    mask = cv2.inRange(hsv, (0, 0, 100),
                       (255, 5, 255))  # (0, 0, 100), (255, 5, 255)
    nzmask = cv2.inRange(hsv, (0, 0, 5),
                         (255, 255, 255))  # (0, 0, 5), (255, 255, 255))
    nzmask = cv2.erode(nzmask, np.ones((3, 3)))  # (3,3)
    mask = mask & nzmask

    new_img = img.copy()
    new_img[np.where(mask)] = 255

    return cv_to_PIL(new_img)


# def super_res(pil_img):
#     # requires opencv-contrib-python installed without the opencv-python
#     sr = dnn_superres.DnnSuperResImpl_create()
#     image = PIL_to_cv(pil_img)
#     model_path = "./LapSRN_x8.pb"
#     model_name = model_path.split('/')[1].split('_')[0].lower()
#     model_scale = int(model_path.split('/')[1].split('_')[1].split('.')[0][1])

#     sr.readModel(model_path)
#     sr.setModel(model_name, model_scale)
#     final_img = sr.upsample(image)
#     final_img = cv_to_PIL(final_img)

#     return final_img


def table_detector(image, THRESHOLD_PROBA):
    '''
    Table detection using DEtect-object TRansformer pre-trained on 1 million tables

    '''

    feature_extractor = DetrImageProcessor(do_resize=True,
                                           size=800,
                                           max_size=800)
    encoding = feature_extractor(image, return_tensors="pt")

    with torch.no_grad():
        outputs = table_detection_model(**encoding)

    probas = outputs.logits.softmax(-1)[0, :, :-1]
    keep = probas.max(-1).values > THRESHOLD_PROBA

    target_sizes = torch.tensor(image.size[::-1]).unsqueeze(0)
    postprocessed_outputs = feature_extractor.post_process(
        outputs, target_sizes)
    bboxes_scaled = postprocessed_outputs[0]['boxes'][keep]

    return (probas[keep], bboxes_scaled)


def table_struct_recog(image, THRESHOLD_PROBA):
    '''
    Table structure recognition using DEtect-object TRansformer pre-trained on 1 million tables
    '''

    feature_extractor = DetrImageProcessor(do_resize=True,
                                           size=1000,
                                           max_size=1000)
    encoding = feature_extractor(image, return_tensors="pt")

    with torch.no_grad():
        outputs = table_recognition_model(**encoding)

    probas = outputs.logits.softmax(-1)[0, :, :-1]
    keep = probas.max(-1).values > THRESHOLD_PROBA

    target_sizes = torch.tensor(image.size[::-1]).unsqueeze(0)
    postprocessed_outputs = feature_extractor.post_process(
        outputs, target_sizes)
    bboxes_scaled = postprocessed_outputs[0]['boxes'][keep]

    return (probas[keep], bboxes_scaled)


class TableExtractionPipeline():

    colors = ["red", "blue", "green", "yellow", "orange", "violet"]

    # colors = ["red", "blue", "green", "red", "red", "red"]

    def add_padding(self,
                    pil_img,
                    top,
                    right,
                    bottom,
                    left,
                    color=(255, 255, 255)):
        '''
        Image padding as part of TSR pre-processing to prevent missing table edges
        '''
        width, height = pil_img.size
        new_width = width + right + left
        new_height = height + top + bottom
        result = Image.new(pil_img.mode, (new_width, new_height), color)
        result.paste(pil_img, (left, top))
        return result

    def plot_results_detection(self, c1, model, pil_img, prob, boxes,
                               delta_xmin, delta_ymin, delta_xmax, delta_ymax):
        '''
        crop_tables and plot_results_detection must have same co-ord shifts because 1 only plots the other one updates co-ordinates 
        '''
        # st.write('img_obj')
        # st.write(pil_img)
        plt.imshow(pil_img)
        ax = plt.gca()

        for p, (xmin, ymin, xmax, ymax) in zip(prob, boxes.tolist()):
            cl = p.argmax()
            xmin, ymin, xmax, ymax = xmin - delta_xmin, ymin - delta_ymin, xmax + delta_xmax, ymax + delta_ymax
            ax.add_patch(
                plt.Rectangle((xmin, ymin),
                              xmax - xmin,
                              ymax - ymin,
                              fill=False,
                              color='red',
                              linewidth=3))
            text = f'{model.config.id2label[cl.item()]}: {p[cl]:0.2f}'
            ax.text(xmin - 20,
                    ymin - 50,
                    text,
                    fontsize=10,
                    bbox=dict(facecolor='yellow', alpha=0.5))
        plt.axis('off')
        c1.pyplot()

    def crop_tables(self, pil_img, prob, boxes, delta_xmin, delta_ymin,
                    delta_xmax, delta_ymax):
        '''
        crop_tables and plot_results_detection must have same co-ord shifts because 1 only plots the other one updates co-ordinates 
        '''
        cropped_img_list = []

        for p, (xmin, ymin, xmax, ymax) in zip(prob, boxes.tolist()):

            xmin, ymin, xmax, ymax = xmin - delta_xmin, ymin - delta_ymin, xmax + delta_xmax, ymax + delta_ymax
            cropped_img = pil_img.crop((xmin, ymin, xmax, ymax))
            cropped_img_list.append(cropped_img)

        return cropped_img_list

    def generate_structure(self, c2, model, pil_img, prob, boxes,
                           expand_rowcol_bbox_top, expand_rowcol_bbox_bottom):
        '''
        Co-ordinates are adjusted here by 3 'pixels'
        To plot table pillow image and the TSR bounding boxes on the table
        '''
        # st.write('img_obj')
        # st.write(pil_img)
        plt.figure(figsize=(32, 20))
        plt.imshow(pil_img)
        ax = plt.gca()
        rows = {}
        cols = {}
        idx = 0

        for p, (xmin, ymin, xmax, ymax) in zip(prob, boxes.tolist()):

            xmin, ymin, xmax, ymax = xmin, ymin, xmax, ymax
            cl = p.argmax()
            class_text = model.config.id2label[cl.item()]
            text = f'{class_text}: {p[cl]:0.2f}'
            # or (class_text == 'table column')
            if (class_text
                    == 'table row') or (class_text
                                        == 'table projected row header') or (
                                            class_text == 'table column'):
                ax.add_patch(
                    plt.Rectangle((xmin, ymin),
                                  xmax - xmin,
                                  ymax - ymin,
                                  fill=False,
                                  color=self.colors[cl.item()],
                                  linewidth=2))
                ax.text(xmin - 10,
                        ymin - 10,
                        text,
                        fontsize=5,
                        bbox=dict(facecolor='yellow', alpha=0.5))

            if class_text == 'table row':
                rows['table row.' +
                     str(idx)] = (xmin, ymin - expand_rowcol_bbox_top, xmax,
                                  ymax + expand_rowcol_bbox_bottom)
            if class_text == 'table column':
                cols['table column.' +
                     str(idx)] = (xmin, ymin - expand_rowcol_bbox_top, xmax,
                                  ymax + expand_rowcol_bbox_bottom)

            idx += 1

        plt.axis('on')
        c2.pyplot()
        return rows, cols

    def sort_table_featuresv2(self, rows: dict, cols: dict):
        # Sometimes the header and first row overlap, and we need the header bbox not to have first row's bbox inside the headers bbox
        rows_ = {
            table_feature: (xmin, ymin, xmax, ymax)
            for table_feature, (
                xmin, ymin, xmax,
                ymax) in sorted(rows.items(), key=lambda tup: tup[1][1])
        }
        cols_ = {
            table_feature: (xmin, ymin, xmax, ymax)
            for table_feature, (
                xmin, ymin, xmax,
                ymax) in sorted(cols.items(), key=lambda tup: tup[1][0])
        }

        return rows_, cols_

    def individual_table_featuresv2(self, pil_img, rows: dict, cols: dict):

        for k, v in rows.items():
            xmin, ymin, xmax, ymax = v
            cropped_img = pil_img.crop((xmin, ymin, xmax, ymax))
            rows[k] = xmin, ymin, xmax, ymax, cropped_img

        for k, v in cols.items():
            xmin, ymin, xmax, ymax = v
            cropped_img = pil_img.crop((xmin, ymin, xmax, ymax))
            cols[k] = xmin, ymin, xmax, ymax, cropped_img

        return rows, cols

    def object_to_cellsv2(self, master_row: dict, cols: dict,
                          expand_rowcol_bbox_top, expand_rowcol_bbox_bottom,
                          padd_left):
        '''Removes redundant bbox for rows&columns and divides each row into cells from columns
        Args:

        Returns:

        
        '''
        cells_img = {}
        header_idx = 0
        row_idx = 0
        previous_xmax_col = 0
        new_cols = {}
        new_master_row = {}
        previous_ymin_row = 0
        new_cols = cols
        new_master_row = master_row
        ## Below 2 for loops remove redundant bounding boxes ###
        # for k_col, v_col in cols.items():
        #     xmin_col, _, xmax_col, _, col_img = v_col
        #     if (np.isclose(previous_xmax_col, xmax_col, atol=5)) or (xmin_col >= xmax_col):
        #         print('Found a column with double bbox')
        #         continue
        #     previous_xmax_col = xmax_col
        #     new_cols[k_col] = v_col

        # for k_row, v_row in master_row.items():
        #     _, ymin_row, _, ymax_row, row_img = v_row
        #     if (np.isclose(previous_ymin_row, ymin_row, atol=5)) or (ymin_row >= ymax_row):
        #         print('Found a row with double bbox')
        #         continue
        #     previous_ymin_row = ymin_row
        #     new_master_row[k_row] = v_row
        ######################################################
        for k_row, v_row in new_master_row.items():

            _, _, _, _, row_img = v_row
            xmax, ymax = row_img.size
            xa, ya, xb, yb = 0, 0, 0, ymax
            row_img_list = []
            # plt.imshow(row_img)
            # st.pyplot()
            for idx, kv in enumerate(new_cols.items()):
                k_col, v_col = kv
                xmin_col, _, xmax_col, _, col_img = v_col
                xmin_col, xmax_col = xmin_col - padd_left - 10, xmax_col - padd_left
                xa = xmin_col
                xb = xmax_col
                if idx == 0:
                    xa = 0
                if idx == len(new_cols) - 1:
                    xb = xmax
                xa, ya, xb, yb = xa, ya, xb, yb

                row_img_cropped = row_img.crop((xa, ya, xb, yb))
                row_img_list.append(row_img_cropped)

            cells_img[k_row + '.' + str(row_idx)] = row_img_list
            row_idx += 1

        return cells_img, len(new_cols), len(new_master_row) - 1

    def clean_dataframe(self, df):
        '''
        Remove irrelevant symbols that appear with tesseractOCR
        '''
        # df.columns = [col.replace('|', '') for col in df.columns]

        for col in df.columns:

            df[col] = df[col].str.replace("'", '', regex=True)
            df[col] = df[col].str.replace('"', '', regex=True)
            df[col] = df[col].str.replace(']', '', regex=True)
            df[col] = df[col].str.replace('[', '', regex=True)
            df[col] = df[col].str.replace('{', '', regex=True)
            df[col] = df[col].str.replace('}', '', regex=True)
        return df

    @st.cache
    def convert_df(self, df):
        return df.to_csv().encode('utf-8')

    def create_dataframe(self, c3, cell_ocr_res: list, max_cols: int,
                         max_rows: int):
        '''Create dataframe using list of cell values of the table, also checks for valid header of dataframe
        Args:
            cell_ocr_res: list of strings, each element representing a cell in a table
            max_cols, max_rows: number of columns and rows
        Returns:
            dataframe : final dataframe after all pre-processing 
        '''

        headers = cell_ocr_res[:max_cols]
        new_headers = uniquify(headers,
                               (f' {x!s}' for x in string.ascii_lowercase))
        counter = 0

        cells_list = cell_ocr_res[max_cols:]
        df = pd.DataFrame("", index=range(0, max_rows), columns=new_headers)

        cell_idx = 0
        for nrows in range(max_rows):
            for ncols in range(max_cols):
                df.iat[nrows, ncols] = str(cells_list[cell_idx])
                cell_idx += 1

        ## To check if there are duplicate headers if result of uniquify+col == col
        ## This check removes headers when all headers are empty or if median of header word count is less than 6
        for x, col in zip(string.ascii_lowercase, new_headers):
            if f' {x!s}' == col:
                counter += 1
        header_char_count = [len(col) for col in new_headers]

        # if (counter == len(new_headers)) or (statistics.median(header_char_count) < 6):
        #     st.write('woooot')
        #     df.columns = uniquify(df.iloc[0], (f' {x!s}' for x in string.ascii_lowercase))
        #     df = df.iloc[1:,:]

        df = self.clean_dataframe(df)

        c3.dataframe(df)
        csv = self.convert_df(df)
        c3.download_button("Download table",
                           csv,
                           "file.csv",
                           "text/csv",
                           key='download-csv')

        return df

    async def start_process(self, image_path: str, TD_THRESHOLD, TSR_THRESHOLD,
                            OCR_THRESHOLD, padd_top, padd_left, padd_bottom,
                            padd_right, delta_xmin, delta_ymin, delta_xmax,
                            delta_ymax, expand_rowcol_bbox_top,
                            expand_rowcol_bbox_bottom):
        '''
        Initiates process of generating pandas dataframes from raw pdf-page images

        '''
        image = Image.open(image_path).convert("RGB")
        probas, bboxes_scaled = table_detector(image,
                                               THRESHOLD_PROBA=TD_THRESHOLD)

        if bboxes_scaled.nelement() == 0:
            st.write('No table found in the pdf-page image')
            return ''

        # try:
        # st.write('Document: '+image_path.split('/')[-1])
        c1, c2, c3 = st.columns((1, 1, 1))

        self.plot_results_detection(c1, table_detection_model, image, probas,
                                    bboxes_scaled, delta_xmin, delta_ymin,
                                    delta_xmax, delta_ymax)
        cropped_img_list = self.crop_tables(image, probas, bboxes_scaled,
                                            delta_xmin, delta_ymin, delta_xmax,
                                            delta_ymax)

        for unpadded_table in cropped_img_list:

            table = self.add_padding(unpadded_table, padd_top, padd_right,
                                     padd_bottom, padd_left)
            # table = super_res(table)
            # table = binarizeBlur_image(table)
            # table = sharpen_image(table) # Test sharpen image next
            # table = td_postprocess(table)

            probas, bboxes_scaled = table_struct_recog(
                table, THRESHOLD_PROBA=TSR_THRESHOLD)
            rows, cols = self.generate_structure(c2, table_recognition_model,
                                                 table, probas, bboxes_scaled,
                                                 expand_rowcol_bbox_top,
                                                 expand_rowcol_bbox_bottom)
            # st.write(len(rows), len(cols))
            rows, cols = self.sort_table_featuresv2(rows, cols)
            master_row, cols = self.individual_table_featuresv2(
                table, rows, cols)

            cells_img, max_cols, max_rows = self.object_to_cellsv2(
                master_row, cols, expand_rowcol_bbox_top,
                expand_rowcol_bbox_bottom, padd_left)

            sequential_cell_img_list = []
            for k, img_list in cells_img.items():
                for img in img_list:
                    # img = super_res(img)
                    # img = sharpen_image(img) # Test sharpen image next
                    # img = binarizeBlur_image(img)
                    # img = self.add_padding(img, 10,10,10,10)
                    # plt.imshow(img)
                    # c3.pyplot()
                    sequential_cell_img_list.append(
                        pytess(cell_pil_img=img, threshold=OCR_THRESHOLD))

            cell_ocr_res = await asyncio.gather(*sequential_cell_img_list)

            self.create_dataframe(c3, cell_ocr_res, max_cols, max_rows)
            st.write(
                'Errors in OCR is due to either quality of the image or performance of the OCR'
            )
        # except:
        #     st.write('Either incorrectly identified table or no table, to debug remove try/except')
        # break
        # break


if __name__ == "__main__":

    img_name = st.file_uploader("Upload an image with table(s)")
    st1, st2, st3 = st.columns((1, 1, 1))
    TD_th = st1.slider('Table detection threshold', 0.0, 1.0, 0.8)
    TSR_th = st2.slider('Table structure recognition threshold', 0.0, 1.0, 0.8)
    OCR_th = st3.slider("Text Probs Threshold", 0.0, 1.0, 0.5)

    st1, st2, st3, st4 = st.columns((1, 1, 1, 1))

    padd_top = st1.slider('Padding top', 0, 200, 40)
    padd_left = st2.slider('Padding left', 0, 200, 40)
    padd_right = st3.slider('Padding right', 0, 200, 40)
    padd_bottom = st4.slider('Padding bottom', 0, 200, 40)

    te = TableExtractionPipeline()
    # for img in image_list:
    if img_name is not None:
        asyncio.run(
            te.start_process(img_name,
                             TD_THRESHOLD=TD_th,
                             TSR_THRESHOLD=TSR_th,
                             OCR_THRESHOLD=OCR_th,
                             padd_top=padd_top,
                             padd_left=padd_left,
                             padd_bottom=padd_bottom,
                             padd_right=padd_right,
                             delta_xmin=0,
                             delta_ymin=0,
                             delta_xmax=0,
                             delta_ymax=0,
                             expand_rowcol_bbox_top=0,
                             expand_rowcol_bbox_bottom=0))