import os, re, operator
from util.ProcessLogger import ProcessLogger
import hashlib

import time

includes_re =  re.compile('\s*#include\s*["<]([^">]*)[">].*')

class toolchain_makefile():
    def __init__(self, CTRInstance):
        self.CTRInstance = CTRInstance
        self.md5key = None 
        self.buildpath = None
        self.SetBuildPath(self.CTRInstance._getBuildPath())

    def SetBuildPath(self, buildpath):
        if self.buildpath != buildpath:
            self.buildpath = buildpath
            self.md5key = None

    def GetBinaryCode(self):
        return None

    def _GetMD5FileName(self):
        return os.path.join(self.buildpath, "lastbuildPLC.md5")

    def ResetBinaryCodeMD5(self):
        self.md5key = None
        try:
            os.remove(self._GetMD5FileName())
        except Exception, e:
            pass

    def GetBinaryCodeMD5(self):
        if self.md5key is not None:
            return self.md5key
        else:
            try:
                return open(self._GetMD5FileName(), "r").read()
            except IOError, e:
                return None

    def concat_deps(self, bn):
        # read source
        src = open(os.path.join(self.buildpath, bn),"r").read()
        # update direct dependencies
        deps = []
        for l in src.splitlines():
            res = includes_re.match(l)
            if res is not None:
                depfn = res.groups()[0]
                if os.path.exists(os.path.join(self.buildpath, depfn)):
                    #print bn + " depends on "+depfn
                    deps.append(depfn)
        # recurse through deps
        # TODO detect cicular deps.
        return reduce(operator.concat, map(self.concat_deps, deps), src)

    def build(self):
        srcfiles= []
        cflags = []
        wholesrcdata = "" 
        for Location, CFilesAndCFLAGS, DoCalls in self.CTRInstance.LocationCFilesAndCFLAGS:
            # Get CFiles list to give it to makefile
            for CFile, CFLAGS in CFilesAndCFLAGS:
                CFileName = os.path.basename(CFile)
                wholesrcdata += self.concat_deps(CFileName)
                #wholesrcdata += open(CFile, "r").read()
                srcfiles.append(CFileName)
                if CFLAGS not in cflags:
                    cflags.append(CFLAGS)
                        
        oldmd5 = self.md5key
        self.md5key = hashlib.md5(wholesrcdata).hexdigest()
        props = self.CTRInstance.GetProjectProperties()
        self.md5key += '#'.join([props[key] for key in ['companyName',
                                                        'projectName',
                                                        'productName']])
        self.md5key += '#' #+','.join(map(str,time.localtime()))
        # Store new PLC filename based on md5 key
        f = open(self._GetMD5FileName(), "w")
        f.write(self.md5key)
        f.close()

        if oldmd5 != self.md5key :
            beremizcommand = {"src": ' '.join(srcfiles),
                              "cflags": ' '.join(cflags),
                              "md5": '"'+self.md5key+'"'
                             }
            
            target = self.CTRInstance.GetTarget().getcontent()
            command = target.getCommand().split(' ') +\
                      [target.getBuildPath()] +\
                      [arg % beremizcommand for arg in target.getArguments().split(' ')] +\
                      target.getRule().split(' ')
            
            # Call Makefile to build PLC code and link it with target specific code
            status, result, err_result = ProcessLogger(self.CTRInstance.logger,
                                                       command).spin()
            if status :
                self.md5key = None
                self.CTRInstance.logger.write_error(_("C compilation failed.\n"))
                return False
            return True
        else :
            self.CTRInstance.logger.write(_("Source didn't change, no build.\n"))
            return True