"""
Functions for parsing comic info from filename

This should probably be re-written, but, well, it mostly works!

Copyright 2012-2014  Anthony Beville

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""

# Some portions of this code were modified from pyComicMetaThis project
# http://code.google.com/p/pycomicmetathis/

import re
import os
from urllib.parse import unquote


class FileNameParser:
    def repl(self, m):
        return ' ' * len(m.group())

    def fixSpaces(self, string, remove_dashes=True):
        if remove_dashes:
            placeholders = ['[-_]', '  +']
        else:
            placeholders = ['[_]', '  +']
        for ph in placeholders:
            string = re.sub(ph, self.repl, string)
        return string

    def getIssueCount(self, filename, issue_end):

        count = ""
        filename = filename[issue_end:]

        # replace any name seperators with spaces
        tmpstr = self.fixSpaces(filename)
        found = False

        match = re.search('(?<=\sof\s)\d+(?=\s)', tmpstr, re.IGNORECASE)
        if match:
            count = match.group()
            found = True

        if not found:
            match = re.search('(?<=\(of\s)\d+(?=\))', tmpstr, re.IGNORECASE)
            if match:
                count = match.group()

        count = count.lstrip("0")

        return count

    def getIssueNumber(self, filename):

        # Returns a tuple of issue number string, and start and end indexs in the filename
        # (The indexes will be used to split the string up for further parsing)

        found = False
        issue = ''
        start = 0
        end = 0

        # first, look for multiple "--", this means it's formatted differently from most:
        if "--" in filename:
            # the pattern seems to be that anything to left of the first "--" is the series name followed by issue
            filename = re.sub("--.*", self.repl, filename)

        elif "__" in filename:
            # the pattern seems to be that anything to left of the first "__" is the series name followed by issue
            filename = re.sub("__.*", self.repl, filename)

        filename = filename.replace("+", " ")

        # replace parenthetical phrases with spaces
        filename = re.sub("\(.*?\)", self.repl, filename)
        filename = re.sub("\[.*?\]", self.repl, filename)

        # replace any name seperators with spaces
        filename = self.fixSpaces(filename)

        # remove any "of NN" phrase with spaces (problem: this could break on some titles)
        filename = re.sub("of [\d]+", self.repl, filename)

        # we should now have a cleaned up filename version with all the words in
        # the same positions as original filename

        # make a list of each word and its position
        word_list = list()
        for m in re.finditer("\S+", filename):
            word_list.append((m.group(0), m.start(), m.end()))

        # remove the first word, since it can't be the issue number
        if len(word_list) > 1:
            word_list = word_list[1:]
        else:
            # only one word??  just bail.
            return issue, start, end

        # Now try to search for the likely issue number word in the list

        # first look for a word with "#" followed by digits with optional sufix
        # this is almost certainly the issue number
        for w in reversed(word_list):
            if re.match("#[-]?(([0-9]*\.[0-9]+|[0-9]+)(\w*))", w[0]):
                found = True
                break

        # same as above but w/o a '#', and only look at the last word in the list
        if not found:
            w = word_list[-1]
            if re.match("[-]?(([0-9]*\.[0-9]+|[0-9]+)(\w*))", w[0]):
                found = True

        # now try to look for a # followed by any characters
        if not found:
            for w in reversed(word_list):
                if re.match("#\S+", w[0]):
                    found = True
                    break

        if found:
            issue = w[0]
            start = w[1]
            end = w[2]
            if issue[0] == '#':
                issue = issue[1:]

        return issue, start, end

    def getSeriesName(self, filename, issue_start):

        # use the issue number string index to split the filename string

        if issue_start != 0:
            filename = filename[:issue_start]

        # in case there is no issue number, remove some obvious stuff
        if "--" in filename:
            # the pattern seems to be that anything to left of the first "--" is the series name followed by issue
            filename = re.sub("--.*", self.repl, filename)

        elif "__" in filename:
            # the pattern seems to be that anything to left of the first "__" is the series name followed by issue
            filename = re.sub("__.*", self.repl, filename)

        filename = filename.replace("+", " ")
        tmpstr = self.fixSpaces(filename, remove_dashes=False)

        series = tmpstr
        volume = ""

        # save the last word
        try:
            last_word = series.split()[-1]
        except:
            last_word = ""

        # remove any parenthetical phrases
        series = re.sub("\(.*?\)", "", series)

        # search for volume number
        match = re.search('(.+)([vV]|[Vv][oO][Ll]\.?\s?)(\d+)\s*$', series)
        if match:
            series = match.group(1)
            volume = match.group(3)

        # if a volume wasn't found, see if the last word is a year in parentheses
        # since that's a common way to designate the volume
        if volume == "":
            # match either (YEAR), (YEAR-), or (YEAR-YEAR2)
            match = re.search("(\()(\d{4})(-(\d{4}|)|)(\))", last_word)
            if match:
                volume = match.group(2)

        series = series.strip()

        # if we don't have an issue number (issue_start==0), look
        # for hints i.e. "TPB", "one-shot", "OS", "OGN", etc that might
        # be removed to help search online
        if issue_start == 0:
            one_shot_words = ["tpb", "os", "one-shot", "ogn", "gn"]
            try:
                last_word = series.split()[-1]
                if last_word.lower() in one_shot_words:
                    series = series.rsplit(' ', 1)[0]
            except:
                pass

        return series, volume.strip()

    def getYear(self, filename, issue_end):

        filename = filename[issue_end:]

        year = ""
        # look for four digit number with "(" ")" or "--" around it
        match = re.search('(\(\d\d\d\d\))|(--\d\d\d\d--)', filename)
        if match:
            year = match.group()
            # remove non-numerics
            year = re.sub("[^0-9]", "", year)
        return year

    def getRemainder(self, filename, year, count, issue_end):

        # make a guess at where the the non-interesting stuff begins
        remainder = ""

        if "--" in filename:
            remainder = filename.split("--", 1)[1]
        elif "__" in filename:
            remainder = filename.split("__", 1)[1]
        elif issue_end != 0:
            remainder = filename[issue_end:]

        remainder = self.fixSpaces(remainder, remove_dashes=False)
        if year != "":
            remainder = remainder.replace(year, "", 1)
        if count != "":
            remainder = remainder.replace("of " + count, "", 1)

        remainder = remainder.replace("()", "")

        return remainder.strip()

    def parseFilename(self, filename):

        # remove the path
        filename = os.path.basename(filename)

        # remove the extension
        filename = os.path.splitext(filename)[0]

        # url decode, just in case
        filename = unquote(filename)

        # sometimes archives get messed up names from too many decodings
        # often url encodings will break and leave "_28" and "_29" in place
        # of "(" and ")"  see if there are a number of these, and replace them
        if filename.count("_28") > 1 and filename.count("_29") > 1:
            filename = filename.replace("_28", "(")
            filename = filename.replace("_29", ")")

        self.issue, issue_start, issue_end = self.getIssueNumber(filename)
        self.series, self.volume = self.getSeriesName(filename, issue_start)
        self.year = self.getYear(filename, issue_end)
        self.issue_count = self.getIssueCount(filename, issue_end)
        self.remainder = self.getRemainder(filename, self.year,
                                           self.issue_count, issue_end)

        if self.issue != "":
            # strip off leading zeros
            self.issue = self.issue.lstrip("0")
            if self.issue == "":
                self.issue = "0"
            if self.issue[0] == ".":
                self.issue = "0" + self.issue
