# pylint: disable=invalid-name,missing-docstring

 import re

 import platform

 from StringUtils import StringUtils

 from SpecStructures import rpmMacro, dependentPackageData, Package

 from constants import constants

 
 class SpecParser(object):

     def __init__(self):

         self.cleanMacro = rpmMacro().setName("clean")
         self.prepMacro = rpmMacro().setName("prep")
         self.buildMacro = rpmMacro().setName("build")
         self.installMacro = rpmMacro().setName("install")
         self.changelogMacro = rpmMacro().setName("changelog")
         self.checkMacro = rpmMacro().setName("check")
         self.packages = {}
         self.specAdditionalContent = ""
         self.globalSecurityHardening = ""
         self.defs = {}

         self.conditionalCheckMacroEnabled = False

         self.macro_pattern = re.compile(r'%{(\S+?)\}')

     def parseSpecFile(self, specfile):
         self._createDefaultPackage()
         currentPkg = "default"
         with open(specfile) as specFile:
             lines = specFile.readlines()
             totalLines = len(lines)
             i = 0
             while i < totalLines:
                 line = lines[i].strip()
                 if self._isConditionalArch(line):
                     if platform.machine() != self._readConditionalArch(line):
                         # skip conditional body
                         deep = 1
                         while i < totalLines and deep != 0:
                             i = i + 1
                             line = lines[i].strip()
                             if self._isConditionalMacroStart(line):
                                 deep = deep + 1
                             elif self._isConditionalMacroEnd(line):
                                 deep = deep - 1
                 elif self._isIfCondition(line):
                     if not self._isConditionTrue(line):
                         # skip conditional body
                         deep = 1
                         while i < totalLines and deep != 0:
                             i = i + 1
                             line = lines[i].strip()
                             if self._isConditionalMacroStart(line):
                                 deep = deep + 1
                             elif self._isConditionalMacroEnd(line):
                                 deep = deep - 1
                 elif self._isSpecMacro(line):
                     macro, i = self._readMacroFromFile(i, lines)
                     self._updateSpecMacro(macro)
                 elif self._isPackageMacro(line):
                     defaultpkg = self.packages.get('default')
                     returnVal, packageName = self._readPkgNameFromPackageMacro(line,
                                                                                defaultpkg.name)
                     packageName = self._replaceMacros(packageName)
                     if not returnVal:
                         return False
                     if line.startswith('%package'):
                         pkg = Package(defaultpkg)
                         pkg.name = packageName
                         currentPkg = packageName
                         self.packages[pkg.name] = pkg
                     else:
                         if defaultpkg.name == packageName:
                             packageName = 'default'
                         macro, i = self._readMacroFromFile(i, lines)
                         if packageName not in self.packages:
                             i = i + 1
                             continue
                         self.packages[packageName].updatePackageMacro(macro)
                 elif self._isPackageHeaders(line):
                     self._readPackageHeaders(line, self.packages[currentPkg])
                 elif self._isGlobalSecurityHardening(line):
                     self._readSecurityHardening(line)
                 elif self._isChecksum(line):
                     self._readChecksum(line, self.packages[currentPkg])
                 elif self._isDefinition(line):
                     self._readDefinition(line)
                 elif self._isConditionalCheckMacro(line):
                     self.conditionalCheckMacroEnabled = True
                 elif self.conditionalCheckMacroEnabled and self._isConditionalMacroEnd(line):
                     self.conditionalCheckMacroEnabled = False
                 else:
                     self.specAdditionalContent += line + "\n"
                 i = i + 1

     def _readPkgNameFromPackageMacro(self, data, basePkgName=None):

         data = " ".join(data.split())
         pkgHeaderName = data.split(" ")

         lenpkgHeaderName = len(pkgHeaderName)

         i = 1

         pkgName = None

         while i < lenpkgHeaderName:

             if pkgHeaderName[i] == "-n" and i+1 < lenpkgHeaderName:
                 pkgName = pkgHeaderName[i+1]
                 break
             if pkgHeaderName[i].startswith('-'):
                 i = i + 2
             else:

                 pkgName = basePkgName + "-" + pkgHeaderName[i]

                 break
         if pkgName is None:

             return True, basePkgName

         return True, pkgName

     def _replaceMacros(self, string):

         """Replace all macros in given string with corresponding values.
 
         For example: a string '%{name}-%{version}.tar.gz' will be transformed to 'foo-2.0.tar.gz'.
 
         :return A string where all macros in given input are substituted as good as possible.
 
         """
         def _is_conditional(macro):

             return macro.startswith(("?", "!"))

 
         def _test_conditional(macro):
             if macro[0] == "?":
                 return True
             if macro[0] == "!":
                 return False
             raise Exception("Given string is not a conditional macro")
 
         def _is_macro_defined(macro):

             return (macro in self.defs.keys()) or (macro in constants.userDefinedMacros.keys()) \
                 or (macro in constants.getAdditionalMacros(self.packages["default"].name).keys())

 
         def _get_macro(macro):
             if macro in self.defs.keys():
                 return self.defs[macro]
             elif macro in constants.userDefinedMacros.keys():
                 return constants.userDefinedMacros[macro]

             elif macro in constants.getAdditionalMacros(self.packages["default"].name).keys():
                 return constants.getAdditionalMacros(self.packages["default"].name)[macro]

             raise Exception("Unknown macro: " + macro)
 
         def _macro_repl(match):
             macro_name = match.group(1)
             if _is_conditional(macro_name):
                 parts = macro_name[1:].split(":")

                 assert parts
                 retv = ""

                 if _test_conditional(macro_name):  # ?
                     if _is_macro_defined(parts[0]):
                         if len(parts) == 2:

                             retv = parts[1]

                         else:

                             retv = _get_macro(parts[0])

                 else:  # !
                     if not _is_macro_defined(parts[0]):
                         if len(parts) == 2:

                             retv = parts[1]
                 return retv

 
             if _is_macro_defined(macro_name):
                 return _get_macro(macro_name)
             return match.string[match.start():match.end()]
 
         #User macros

         for macroName, value in constants.userDefinedMacros.items():

             macro = "%" + macroName

             if string.find(macro) != -1:

                 string = string.replace(macro, value)

         #Spec definitions

         for macroName, value in self.defs.items():

             macro = "%" + macroName

             if string.find(macro) != -1:

                 string = string.replace(macro, value)

         return re.sub(self.macro_pattern, _macro_repl, string)
 

     def _createDefaultPackage(self):
         self.packages["default"] = Package()

     def _readMacroFromFile(self, currentPos, lines):

         macro = rpmMacro()
         line = lines[currentPos]
         macro.position = currentPos

         macro.endposition = currentPos
         endPos = len(lines)

         line = " ".join(line.split())
         flagindex = line.find(" ")
         if flagindex != -1:

             macro.macroFlag = line[flagindex+1:]
             macro.macroName = line[:flagindex]

         else:

             macro.macroName = line

         if currentPos + 1 < len(lines) and self._isMacro(lines[currentPos+1]):

             return macro, currentPos

         for j in range(currentPos + 1, endPos):

             content = lines[j]

             if j+1 < endPos and self._isMacro(lines[j+1]):

                 return macro, j

             macro.content += content +'\n'

             macro.endposition = j
         return macro, endPos

     def _updateSpecMacro(self, macro):

         if macro.macroName == "%clean":

             self.cleanMacro = macro

             return True
         if macro.macroName == "%prep":

             self.prepMacro = macro

             return True
         if macro.macroName == "%build":

             self.buildMacro = macro

             return True
         if macro.macroName == "%install":

             self.installMacro = macro

             return True
         if macro.macroName == "%changelog":

             self.changelogMacro = macro

             return True
         if macro.macroName == "%check":

             self.checkMacro = macro

             return True
         return False

     def _isMacro(self, line):
         return (self._isPackageMacro(line) or
                 self._isSpecMacro(line) or
                 self._isConditionalMacroStart(line) or
                 self._isConditionalMacroEnd(line))

     def _isConditionalArch(self, line):

         if re.search('^'+'%ifarch', line):

             return True
         return False

     def _isSpecMacro(self, line):

         if line.startswith(('%clean', '%prep', '%build', '%install', '%changelog', '%check')):

             return True
         return False

     def _isPackageMacro(self, line):

         line = line.strip()
         if line.startswith(('%post', '%postun', '%files', '%description', '%package')):

             return True
         return False

     def _isPackageHeaders(self, line):

         headersPatterns = ['^summary:', '^name:', '^group:',
                            '^license:', '^version:', '^release:',
                            '^distribution:', '^requires:',

                            r'^requires\((pre|post|preun|postun)\):',

                            '^provides:', '^obsoletes:', '^conflicts:',
                            '^url:', '^source[0-9]*:', '^patch[0-9]*:',
                            '^buildrequires:', '^buildprovides:',
                            '^buildarch:']
         if any([re.search(r, line, flags=re.IGNORECASE) for r in headersPatterns]):

             return True
         return False
 

     def _isGlobalSecurityHardening(self, line):

         if re.search('^%global *security_hardening', line, flags=re.IGNORECASE):

             return True
         return False
 

     def _isChecksum(self, line):

         if re.search('^%define *sha1', line, flags=re.IGNORECASE):

             return True
         return False
 

     def _isDefinition(self, line):

         if line.startswith(('%define', '%global')):

             return True
         return False
 

     def _readConditionalArch(self, line):

         w = line.split()

         if len(w) == 2:

             return w[1]

         return None
 

     def _readDefinition(self, line):

         listDefines = line.split()

         if len(listDefines) == 3:

             self.defs[listDefines[1]] = self._replaceMacros(listDefines[2])

             return True

         return False
 

     def _readHeader(self, line):

         headerSplitIndex = line.find(":")
         if headerSplitIndex + 1 == len(line):
             print(line)
             print("Error:Invalid header")
             return False, None, None
         headerName = line[0:headerSplitIndex].lower()
         headerContent = line[headerSplitIndex + 1:].strip()
         return True, headerName, headerContent
 

     def _readDependentPackageData(self, line):

         strUtils = StringUtils()

         listPackages = line.split(",")
         listdependentpkgs = []

         for line in listPackages:

             line = strUtils.getStringInConditionalBrackets(line)
             listContents = line.split()

             totalContents = len(listContents)

             i = 0

             while i < totalContents:
                 dpkg = dependentPackageData()

                 compare = None
                 packageName = listContents[i]

                 if listContents[i].startswith("/"):

                     provider = constants.providedBy.get(listContents[i], None)
                     i += 1

                     if provider is not None:

                         packageName = provider

                     else:
                         continue

                 if i + 2 < len(listContents):

                     if listContents[i+1] in (">=", "<=", "=", "<", ">"):
                         compare = listContents[i+1]

                 if compare is not None:

                     dpkg.package = packageName
                     dpkg.compare = compare
                     dpkg.version = listContents[i+2]
                     i = i + 3

                 else:

                     dpkg.package = packageName
                     i = i + 1

                 listdependentpkgs.append(dpkg)
         return listdependentpkgs
 

     def _readPackageHeaders(self, line, pkg):
         returnVal, headerName, headerContent = self._readHeader(line)

         if not returnVal:
             return False
 

         headerContent = self._replaceMacros(headerContent)

         if headerName == 'summary':

             pkg.summary = headerContent

             return True
         if headerName == 'name':

             pkg.name = headerContent
             if pkg == self.packages["default"]:

                 self.defs["name"] = pkg.name

             return True
         if headerName == 'group':

             pkg.group = headerContent

             return True
         if headerName == 'license':

             pkg.license = headerContent

             return True
         if headerName == 'version':

             pkg.version = headerContent
             if pkg == self.packages["default"]:

                 self.defs["version"] = pkg.version

             return True
         if headerName == 'buildarch':

             pkg.buildarch = headerContent

             return True
         if headerName == 'release':

             pkg.release = headerContent
             if pkg == self.packages["default"]:

                 self.defs["release"] = pkg.release

             return True
         if headerName == 'distribution':

             pkg.distribution = headerContent

             return True

         if headerName == 'url':

             pkg.URL = headerContent

             return True

         if 'source' in headerName:

             pkg.sources.append(headerContent)
             return True

         if 'patch' in headerName:

             pkg.patches.append(headerContent)
             return True

         if (headerName.startswith('requires') or
                 headerName == 'provides' or
                 headerName == 'obsoletes' or
                 headerName == 'conflicts' or
                 headerName == 'buildrequires' or
                 headerName == 'buildprovides'):

             dpkg = self._readDependentPackageData(headerContent)

             if dpkg is None:
                 return False

             if headerName.startswith('requires'):

                 pkg.requires.extend(dpkg)
             if headerName == 'provides':
                 pkg.provides.extend(dpkg)
             if headerName == 'obsoletes':
                 pkg.obsoletes.extend(dpkg)
             if headerName == 'conflicts':
                 pkg.conflicts.extend(dpkg)
             if headerName == 'buildrequires':

                 if self.conditionalCheckMacroEnabled:
                     pkg.checkbuildrequires.extend(dpkg)
                 else:
                     pkg.buildrequires.extend(dpkg)

             if headerName == 'buildprovides':
                 pkg.buildprovides.extend(dpkg)

             return True
         return False

     def _readSecurityHardening(self, line):

         data = line.lower().strip()
         words = data.split(" ")

         nrWords = len(words)

         if nrWords != 3:
             print("Error: Unable to parse line: " + line)

             return False

         if words[2] != "none" and words[2] != "nonow" and words[2] != "nopie":
             print("Error: Invalid security_hardening value: " + words[2])

             return False
         self.globalSecurityHardening = words[2]

         return True

     def _readChecksum(self, line, pkg):

         strUtils = StringUtils()

         line = self._replaceMacros(line)

         data = line.strip()
         words = data.split()

         nrWords = len(words)

         if nrWords != 3:
             print("Error: Unable to parse line: " + line)

             return False

         value = words[2].split("=")
         if len(value) != 2:
             print("Error: Unable to parse line: "+line)

             return False

         matchedSources = []

         for source in pkg.sources:

             sourceName = strUtils.getFileNameFromURL(source)

             if sourceName.startswith(value[0]):

                 matchedSources.append(sourceName)

         if not matchedSources:

             print("Error: Can not find match for sha1 " + value[0])

             return False

         if len(matchedSources) > 1:

             print("Error: Too many matched Sources:" +
                   ' '.join(matchedSources) + " for sha1 " + value[0])

             return False
         pkg.checksums[sourceName] = value[1]

         return True

     def _isConditionalCheckMacro(self, line):

         data = line.strip()
         words = data.split()
         nrWords = len(words)

         if nrWords != 2:

             return False

         if words[0] != "%if" or words[1] != "%{with_check}":

             return False
         return True
 

     def _isIfCondition(self, line):

         return line.startswith("%if ")
 
     # Supports only %if %{}

     def _isConditionTrue(self, line):

         data = line.strip()
         words = data.split()
         nrWords = len(words)
         # condition like %if a > b is not supported

         if nrWords != 2:

             return True

         if self._replaceMacros(words[1]) == "0":

             return False
         return True
 

     def _isConditionalMacroStart(self, line):

         return line.startswith("%if")
 

     def _isConditionalMacroEnd(self, line):
         return line.strip() == "%endif"