import os
import time
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
from reportlab.pdfgen.canvas import Canvas
from reportlab.lib import units
import reportlab.lib.pagesizes
import sys

class Margins(object):
    def __init__(self, right, left, top, bottom):
        self._right = right
        self._left = left
        self._top = top
        self._bottom = bottom

    @property
    def right(self):
        return self._right * units.cm

    @property
    def left(self):
        return self._left * units.cm

    @property
    def top(self):
        return self._top * units.cm

    @property
    def bottom(self):
        return self._bottom * units.cm

    def adjustLeft(self, width):
        self._left -= width / units.cm


class PDFCreator(object):

    appName = "txt2pdf (version 1.0)"

    def __init__(self, margins, num_lines, output_filename, tmp_filename):
        print 'Start of pdf creation...\n'
        num_lines
        page_width = 210.24
        page_height = 419.52771
        output = 'C:\\Users\\user\\Desktop\\Projects\\Micros PDF Retreiver Project\\test-journal\\PDF\\' + output_filename
        file = 'C:\\Users\\user\\Desktop\\Projects\\Micros PDF Retreiver Project\\test-journal\\PDF\\' + tmp_filename
        print output + '\n'
        print file + '\n'
        one_line_pt = 9.64

        if num_lines > 39:
            extra_lines = num_lines - 39
            page_height = page_height + (one_line_pt * extra_lines)
        elif num_lines < 39:
            extra_lines = 39 - num_lines
            page_height = page_height - (one_line_pt * extra_lines)
        else:
            page_height = 419.52771
        print 'Setting up dimentions...\n'
        pageWidth, pageHeight = reportlab.lib.pagesizes.__dict__['A4']
        self.author = 'name'
        self.title = 'Receipt'
        self.canvas = Canvas(output, pagesize=(page_width, page_height))
        self.canvas.setCreator(self.appName)
        self.fontSize = 8.0
        self.font = 'Courier'
        self.kerning = 0.0
        self.margins = margins
        extra_vertical_space = 0.0
        self.leading = (extra_vertical_space + 1.2) * self.fontSize
        self.linesPerPage = int(
            (self.leading + pageHeight
             - margins.top - margins.bottom - self.fontSize) / self.leading)
        self.lppLen = len(str(self.linesPerPage))
        fontWidth = self.canvas.stringWidth(
            ".", fontName=self.font, fontSize=self.fontSize)
        self.lineNumbering = False
        if self.lineNumbering:
            margins.adjustLeft(fontWidth * (self.lppLen + 2))
        contentWidth = pageWidth - margins.left - margins.right
        self.charsPerLine = int(
            (contentWidth + self.kerning) / (fontWidth + self.kerning))
        self.top = pageHeight - margins.top - self.fontSize
        self.filename = file
        self.verbose = True
        self.breakOnBlanks = False
        self.encoding = 'utf8'
        self.pageNumbering = False
        if self.pageNumbering:
            self.pageNumberPlacement = \
                (pageWidth / 2, margins.bottom / 2)

    def _process(self, data):
        flen = os.fstat(data.fileno()).st_size
        lineno = 0
        read = 0
        for line in data:
            lineno += 1
            if sys.version_info.major == 2:
                read += len(line)
                yield flen == \
                      read, lineno, line.decode(self.encoding).rstrip('\r\n')
            else:
                read += len(line.encode(self.encoding))
                yield flen == read, lineno, line.rstrip('\r\n')

    def _readDocument(self):
        with open(self.filename, 'r') as data:
            for done, lineno, line in self._process(data):
                if len(line) > self.charsPerLine:
                    while len(line) > self.charsPerLine:
                        yield done, line[:self.charsPerLine]
                        line = line[self.charsPerLine:]
                yield done, line

    def _newpage(self):
        textobject = self.canvas.beginText()
        textobject.setFont(self.font, self.fontSize, leading=self.leading)
        textobject.setTextOrigin(self.margins.left, self.top)
        textobject.setCharSpace(self.kerning)
        if self.pageNumbering:
            self.canvas.drawString(
                self.pageNumberPlacement[0],
                self.pageNumberPlacement[1],
                str(self.canvas.getPageNumber()))
        return textobject

    def _scribble(self, text):
        if self.verbose:
            sys.stderr.write(text + os.linesep)

    def generate(self):
        print 'Inside the generating function...\n'
        if self.breakOnBlanks:
            pageno = self._generateBob(self._readDocument())
        else:
            pageno = self._generatePlain(self._readDocument())

    def _generatePlain(self, data):
        pageno = 1
        lineno = 0
        page = self._newpage()
        for _, line in data:
            page.textLine(line)
            lineno += 1
            if lineno == self.linesPerPage:
                self.canvas.drawText(page)
                self.canvas.showPage()
                lineno = 0
                pageno += 1
                page = self._newpage()
        if lineno > 0:
            self.canvas.drawText(page)
        else:
            pageno -= 1
        self.canvas.save()
        return pageno

    def _writeChunk(self, page, chunk, lineno):
        if self.lineNumbering:
            formatstr = '%%%dd: %%s' % self.lppLen
            for index, line in enumerate(chunk):
                page.textLine(
                    formatstr % (lineno - len(chunk) + index + 1, line))
        else:
            for line in chunk:
                page.textLine(line)

    def _generateBob(self, data):
        pageno = 1
        lineno = 0
        page = self._newpage()
        chunk = list()
        for last, line in data:
            if lineno == self.linesPerPage:
                self.canvas.drawText(page)
                self.canvas.showPage()
                lineno = len(chunk)
                pageno += 1
                page = self._newpage()
            lineno += 1
            chunk.append(line)
            if last or len(line.strip()) == 0:
                self._writeChunk(page, chunk, lineno)
                chunk = list()
        if lineno > 0:
            self.canvas.drawText(page)
            self.canvas.showPage()
        else:
            pageno -= 1
        if len(chunk) > 0:
            page = self._newpage()
            self.canvas.drawText(page)
            self.canvas.showPage()
            pageno += 1
        self.canvas.save()
        return pageno

def parse_generate_PDF(file_path):

    from time import gmtime, strftime

    time_seconds = strftime("%S", gmtime())


    def getSize(files_name):
        st = os.stat(files_name)
        return int(st.st_size)


    bigger = False

    print "File path before size: " + file_path + "\n"
    filesize = getSize(file_path)
    print 'File size is: ' + str(filesize) + '\n'
    if filesize < 2500:
        SEEK_OFFSET = -filesize
    else:
        SEEK_OFFSET = -2500
        bigger = True

    last_receipt = ''
    print 'File path is: ' + file_path + '\n'
    with open(file_path) as f:
        f.seek(SEEK_OFFSET, 2)
        FILE_OFFSET = f.tell()
        lines = f.read()
        receipts = lines.split("================================")
        if bigger is False or (bigger is True and len(receipts) > 2):
            last_receipt = receipts[len(receipts) - 2]
        elif bigger is True and len(receipts) == 2:
            num_of_elements = 2
            while num_of_elements == 2:
                if FILE_OFFSET <= 200:
                    SEEK_OFFSET = 0
                    f.seek(SEEK_OFFSET)
                    lines = f.read()
                    receipts = lines.split("================================")
                    last_receipt = receipts[len(receipts) - 2]
                    break
                elif FILE_OFFSET > 200:
                    SEEK_OFFSET = FILE_OFFSET - 200
                    f.seek(SEEK_OFFSET)
                    FILE_OFFSET = f.tell()
                    lines = f.read()
                    receipts = lines.split("================================")
                    num_of_elements = len(receipts)
                    if num_of_elements > 2:
                        last_receipt = receipts[len(receipts) - 2]
                        break

    lines = last_receipt.split("\n")
    match = False
    match_index = -1
    for index, line in enumerate(lines):
        if 'Chk ' in line:
            match = True
            match_index = index

    if match == False:
        quit()
    else:
        header = "           store name\n" \
                 "        company name\n" \
                 "         Tel#: +000-1123456\n" \
                 "         VAT NUM: 1111 - 222\n\n"

        line1 = lines[match_index + 1].split(' ')
        line1_tmp = ''
        for element_index, element in enumerate(line1):
            if element_index == len(line1) - 2 and element != ' ':
                break
            elif element_index == len(line1) - 2:
                break
            else:
                line1_tmp = line1_tmp + ' ' + element
        line1 = str(line1_tmp)
        line1 = line1 + "\n----------------------------------------\n"
        line2 = lines[match_index] + "            " + lines[match_index + 3][-14:] + "\n"
        line3 = "----------------------------------------\n"
        linerest = ""
        for item in range(match_index + 5, len(lines), 1):
            linerest += lines[item] + "\n"
        all_lines = line1 + line2 + line3 + linerest

        spaces = ' ' * 4
        footer = spaces + "Thank You. Please visit us again\n" \
                 + spaces + "================================\n" \
                 + spaces + "You can use your some Card\n" \
                 + spaces + "here. If for any reason you are\n" \
                 + spaces + "no satisfied with your\n" \
                 + spaces + "merchandise, exchange of goods\n" \
                 + spaces + "is permitted within 14 days.\n" \
                 + spaces + "Refund permitted with 7\n" \
                 + spaces + "days on an some Card. No\n" \
                 + spaces + "cash refunds. Ask in store for\n" \
                 + spaces + "full details of our Exchange\n" \
                 + spaces + "and refund policy."

        full_receipt = header + all_lines + footer
        print full_receipt
        tmp_datetime = lines[match_index + 3][-14:].split(" ")
        date = tmp_datetime[0].replace("'", "")
        time = tmp_datetime[1].replace(":", "-")
        datetime = date + "_" + time
        chk_num = lines[match_index].strip().replace(" ", "")
        output_filename = chk_num + "-" + datetime + "-" + time_seconds + ".pdf"
        tmp_filename = chk_num + "_" + datetime + "_" + time_seconds + ".tmp"
        print "output filename: " + output_filename + "\n"
        print "tmp_filename: " + tmp_filename + "\n"
        temp_file = open('C:\\Users\\user\\Desktop\\Projects\\Micros PDF Retreiver Project\\test-journal\\PDF\\' + tmp_filename, "w+")
        temp_file.write(full_receipt)
        temp_file.close()
        split_lines = full_receipt.split("\n")
        num_lines = len(split_lines)

        print "Num of lines: " + str(num_lines)

        one_line_cm = 0.34
        top_margin = 15.8

        if num_lines > 39:
            extra_lines = num_lines - 39
            top_margin = top_margin - (extra_lines * one_line_cm)
        elif num_lines < 39:
            extra_lines = 39 - num_lines
            top_margin = top_margin + (extra_lines * one_line_cm)

        PDFCreator(Margins(0.25, 0.25, top_margin, 0.41), num_lines, output_filename, tmp_filename).generate()
        os.remove('C:\\Users\\user\\Desktop\\Projects\\Micros PDF Retreiver Project\\test-journal\\PDF\\' + tmp_filename)


class MyHandler(PatternMatchingEventHandler):

    patterns = ["*.jnl", "*.txt"]

    def process(self, event):
        print 'generating pdf for ',event.src_path
        parse_generate_PDF(event.src_path)

    def on_modified(self, event):
        self.process(event)


if __name__ == '__main__':
    print "starting watchdog...\n"
    observer = Observer()
    observer.schedule(MyHandler(), path=r"C:\Users\user\Desktop\Projects\Micros PDF Retreiver Project\test-journal")
    print "Monitoring directory...\n"
    observer.daemon = True
    observer.start()
    print "watchdog started...\n"

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()

    observer.join()

'''
-PDF files are not getting generated.
-On line 215 filesize is printed as 0 I am not sure why. Running this function separately shows correct size
-On line 341 seem to run twice since I see two files sometimes...
-Weird behaviour....It runs normally when in debug mode inside PyCharm... WHen running normally though it sometimes runs only the first two creating two instances of the PDF file and then when modifying a file it captures the event but never creates a file, after that any modification is not even captured ....