from typing import List
from src.models.line import Line


class Block:
    def __init__(self) -> None:
        self.lines: List[Line] = []
        self.page: int = 0
        self.reason: str = ""
        self.id: str = ""

        self.left: int = 0
        self.top: int = 0
        self.height: int = 0
        self.width: int = 0

    def __str__(self) -> str:
        return f"Block: page={self.page}, id={self.id}, (x1,y1)=({self.left}, {self.top}), (x2,y2)=({self.left + self.width},{self.top + self.height})"

    def add_line(self, line):
        self.lines.append(line)

class Line:
    def __init__(self, id_: str, page: int, text: str, top: int, left: int, width: int, height: int) -> None:
        self.top: int = top
        self.left: int = left
        self.width: int = width
        self.height: int = height

        self.page: int = page
        self.id_: str = id_
        self.text: str = text
        self.center: list = self.get_center()

    def __str__(self) -> str:
        return (f"Line: \t page={self.page}, "
                f"Id={self.id_}, "
                f"Text={self.text}, \n"
                f"left={self.left}, top={self.top}); "
                f"width={self.width}, height={self.height} \n")

    def get_center(self) -> list:
        x = self.left
        y = self.top
        x1 = self.left + self.width
        y1 = self.top + self.height
        x_center = (x + x1) / 2
        y_center = (y + y1) / 2
        return [x_center, y_center]

class Page:
    def __init__(self, page_number, lines):
        self.lines = lines
        self.page = page_number

    def __str__(self):
        for line in self.lines:
            print(f"line: {line.__str__()}")
        return f"Page: {self.page}"

class ProcessType:
    LINE = "LINE"
    WORD = "WORD"

# response
import json
from PIL import Image
from pdf2image import convert_from_bytes
from typing import List


def read_json_file(file_path):
    with open(file_path, "r") as file:
        return json.load(file)


def read_file_to_bytes(file_path: str) -> List[Image.Image]:
    with open(file_path, 'rb') as file:
        pdf_binary = file.read()
    return convert_from_bytes(pdf_binary)

import math
import re
from typing import List

from pdf2image import convert_from_bytes
from matplotlib.patches import Rectangle

from src.models.block import Block
from src.models.line import Line
from src.ocr.util.functions import read_json_file
from matplotlib import pyplot as plt


class ColumnType:
    """
    Column type, based on the column type of pdf.
    """
    SINGLE = "SINGLE"
    MULTI = "MULTI"


def get_lines_from_json(file_path: str) -> List[Line]:
    """
    Get all type "LINE" from json file generated by textract.
    :param file_path: json file generated by textract.
    :return: list of Line.
    """
    lines: List[Line] = []
    json_res = read_json_file(file_path)
    for item in json_res["Blocks"]:
        if item["BlockType"] == "LINE":
            box = item["Geometry"]["BoundingBox"]
            lines.append(
                Line(
                    item["Id"],
                    item["Page"],
                    item["Text"],
                    box["Top"],
                    box["Left"],
                    box["Width"],
                    box["Height"]))
    return lines


def print_blocks(blocks: List[Block]) -> None:
    """
    print block and line information
    :param blocks: blocks to print
    """
    for block in blocks:
        print(f"{block.__str__()}")
        for line in block.lines:
            print(f"{line.__str__()}")
        print("\n")


class LineSimilarityChecker:
    """
    This class is used to check the similarity between two lines.
    """

    def __init__(self, column_type: ColumnType,
                 distance_tolerance: float = 0.03,
                 width_tolerance: float = 0.01,
                 left_tolerance: float = 0.02,
                 height_tolerance: float = 0.02,
                 same_line_tolerance: float = 0.005
                 ) -> None:
        self.column_type = column_type

        self.distance_tolerance = distance_tolerance
        self.width_tolerance = width_tolerance
        self.left_tolerance = left_tolerance
        self.height_tolerance = height_tolerance
        self.same_line_tolerance = same_line_tolerance

    def is_left_similar(self, line1, line2, tolerance=None):
        tolerance = tolerance or self.left_tolerance
        return self.pretty_similar(line1.left, line2.left, tolerance)

    def is_width_similar(self, line1, line2, tolerance=None):
        tolerance = tolerance or self.width_tolerance
        return self.pretty_similar(line1.width, line2.width, tolerance)

    def is_height_similar(self, line1, line2, tolerance=None):
        tolerance = tolerance or self.height_tolerance
        return self.two_point_height(line1.top, line2.top) < tolerance

    def is_center_close(self, line1: Line, line2: Line) -> bool:
        return self.two_point_distance(
            line1.center[0],
            line1.center[1],
            line2.center[0],
            line2.center[1]) < self.distance_tolerance

    @staticmethod
    def pretty_similar(x: float, x1: float, tolerance: float):
        return abs(x - x1) < tolerance

    @staticmethod
    def two_point_distance(x: float, y: float, x1: float, y1: float):
        distance = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
        return distance

    @staticmethod
    def two_point_height(y: float, y1: float):
        return abs(y - y1)


class LineMerger:
    """
    This class is used to turn lines to blocks by compare each line's similarity.
    """

    def __init__(self, lines, column_type: ColumnType = ColumnType.SINGLE):
        self.column_type = column_type
        self.line_check = LineSimilarityChecker(self.column_type)
        self.lines: List[Line] = lines

    def get_blocks(self) -> List[Block]:
        """
        Get all blocks after turning lines into blocks.
        :param column_type: column is SINGLE or MULTI default is SINGLE
        :return: blocks
        """
        blocks = self.merge_lines_to_block(self.lines)
        return self.find_block_corners(blocks)

    def merge_lines_to_block(self, lines) -> List[Block]:
        blocks: List[Block] = []
        while lines:
            block = Block()
            block.add_line(lines.pop(0))
            block.page = block.lines[0].page
            target_line = block.lines[0]
            index = 0
            while index < len(lines):
                cur_line = lines[index]
                if target_line.page == cur_line.page:
                    # for single column, when encounter number point, make a
                    # new a block
                    if self.column_type == ColumnType.SINGLE and self.is_start_special_word(
                            cur_line):
                        print("---Found special word---")
                        print(cur_line.text)
                        print("---End special word: Jump to next block---")
                        break
                    # other case, all need to compare the lines are close or
                    # not.
                    else:
                        if self.is_two_line_close(block, cur_line):
                            block.add_line(cur_line)
                            lines.pop(index)
                            index = 0
                            continue
                index += 1
            blocks.append(block)
        return blocks

    def is_start_special_word(self, cur_line: Line):
        # 先去字串前後空白 根據空白進行split，取第一個字串
        curStart = cur_line.text.strip().split(" ")[0]
        pattern = self._regex_pattern()

        if re.match(pattern, curStart):
            return True
        else:
            return False

    @staticmethod
    def _regex_pattern() -> str:
        # general word or number + "."  + any words (e.g. 1.Hello my friend)
        GENERAL_WORD_DOT_PATTERN = r'^[a-zA-Z0-9]\..*'
        # non-general one word or number + general one word or num + any word (e.g (1) This is ...)
        NON_ALPHANUMERIC_WORD_PATTERN = r'[^a-zA-Z0-9][a-zA-Z0-9][^a-zA-Z0-9].*'

        return '{}|{}'.format(
            GENERAL_WORD_DOT_PATTERN,
            NON_ALPHANUMERIC_WORD_PATTERN)

    def is_two_line_close(self, block, cur_line):
        last_line: Line = block.lines[-1]
        target_line: Line = block.lines[0]

        if self.is_on_same_page(target_line, cur_line):
            # multi column: center text & paragraph block
            if self.column_type == ColumnType.MULTI:
                if (self.is_same_paragraph(last_line, cur_line) or
                        self.is_text_center_context(last_line, cur_line)):
                    return True

            # single column: same line
            elif self.column_type == ColumnType.SINGLE:
                if (self.is_on_same_line(last_line, cur_line) or
                        self.is_same_paragraph(last_line, cur_line)):
                    return True

        return False

    @staticmethod
    def is_on_same_page(line1, line2) -> bool:
        return line1.page == line2.page

    def is_on_same_line(self, last_line, cur_line) -> bool:
        return self.line_check.is_height_similar(last_line, cur_line)

    def is_same_paragraph(
            self,
            last_line: Line,
            cur_line: Line) -> bool:
        if (self.line_check.is_left_similar(last_line, cur_line)
                and self.line_check.is_height_similar(last_line, cur_line)):
            return True

        return False

    def is_text_center_context(self, last_line: Line, cur_line: Line) -> bool:
        return (self.line_check.is_center_close(last_line, cur_line) and
                self.line_check.is_height_similar(last_line, cur_line))

    @staticmethod
    def find_block_corners(blocks: List[Block]) -> List[Block]:
        for index, block in enumerate(blocks):
            min_top = min(line.top for line in block.lines)
            min_left = min(line.left for line in block.lines)
            max_bottom = max(line.top + line.height for line in block.lines)
            max_right = max(line.left + line.width for line in block.lines)

            block.height = max_bottom - min_top
            block.width = max_right - min_left
            block.top = min_top
            block.left = min_left
            block.id = index

        return blocks


def show_image_bbox(pdf_file, blocks) -> None:
    """
    show image bounding box
    :param pdf_file: the pdf file location
    :param blocks: the list of blocks we want to draw
    """
    with open(pdf_file, 'rb') as file:
        images = convert_from_bytes(file.read())

    for index, image in enumerate(images):
        width, height = image.size
        page = index + 1
        print(f"Process Page Index: {page}")

        plt.figure(figsize=(20, 16))
        plt.imshow(image)

        # iterate over the blocks
        for i, block in enumerate(blocks):
            if block.page == page:
                rect = Rectangle(
                    (width * block.left,
                     height * block.top),
                    block.width * width,
                    block.height * height,
                    edgecolor='r',
                    facecolor='none')
                plt.text(
                    width * block.left,
                    height * block.top,
                    block.id,
                    fontsize=12,
                    color='red')
                plt.gca().add_patch(rect)
        plt.show()