# Copyright (c) 2010 Symbian Foundation Ltd
# This component and the accompanying materials are made available
# under the terms of the License "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Symbian Foundation Ltd - initial contribution.
#
# Contributors:
# mattd <mattd@symbian.org>
#
# Description:
# DBREnv - OO rewrite of the Environments  

#I'm using the existing stuff as helpers until things get relocated...
import os.path
import glob

import dbrutils
import dbrbaseline
import dbrpatch


def CreateDB(location): #virtual constructor
  print location
#  print dbrutils.patch_path_internal()
  if(os.path.isfile(os.path.join(location,dbrutils.defaultdb()))):
#    print 'loading baseline environment'
#    return DBRBaselineEnv(location)
    print 'loading patched baseline environment'
    return DBRPatchedBaselineEnv(location)
  if(os.path.exists(os.path.join(location,'build_md5.zip'))):
    print 'loading zipped environment'
    return DBRZippedEnv(location)
  if(os.path.exists(os.path.join(location,dbrutils.patch_path_internal()))): #should do something more fun with creating a basleine if we have MD5s
    print 'loading new env...warning: this is only here for compatibility'
    return DBRNewLocalEnv(location)
  if(os.path.exists(os.path.join(location,'epoc32'))): 
    print 'loading localenv'
    return DBRLocalEnv(location)

  return DBREnv(location)

#Start simple with the filtering...
def CreateFilter(arg):
  if(os.path.isfile(arg)):
    return DBRFileFilter(arg)
  return DBRFilter()     

class DBREnv:
  db = dict()
  location = ''
  name = ''
  def __init__(self, location):
    self.location = location

  def compare(self, other):
    db1files = set(self.db.keys())
    db2files = set(other.db.keys())

    removed = db1files - db2files
    added = db2files - db1files
    common = db1files & db2files

    touched = set()
    for file in common:
      if(int(self.db[file]['time']) != int(other.db[file]['time'])):
        touched.add(file)

    sizechanged = set()
    for file in common:
      if(int(self.db[file]['size']) != int(other.db[file]['size'])):
        sizechanged.add(file)
#can be funny with some zip files...suggest we don't use sizechanged...        
#    changed = sizechanged 
    changed = set()    
    touched = touched - changed
    unknown = set()
    for file in touched:
      if((self.db[file]['md5'] == "xxx") or (other.db[file]['md5'] == "xxx")):
        unknown.add(file)
#        if((self.db[file]['md5'] == "xxx")):
#          print 'unknown left: %s' % file
#        else:
#          print 'unknown right: %s' % file
      else:
        if(self.db[file]['md5'] != other.db[file]['md5']):
#          print '%s %s %s' % (file, self.db[file]['md5'], other.db[file]['md5'] )
          changed.add(file)
    touched = touched - unknown     
    touched = touched - changed     
          
    results = DBRCompResults(added, removed, touched, changed, unknown)   
    return results
    
  def verify(self, files):
    print 'this is a pure virtual...'
  def save(self):
    print 'this is a pure virtual...'

  def remove(self, files):
    for file in files:
      if(file in self.db):
        del self.db[file]
      else:
        print 'warning: del: %s isnt defined' % file  

  def add(self, other, files):
    for file in files:
      if(file in self.db):
        print 'warning: add: %s already defined' % file
      else:    
        if(other.db[file]['md5'] == 'xxx'): #don't update a null md5
          print 'warning: MD5: %s isnt defined' % file  
        else:
          self.db[file] = other.db[file]
              
  def update(self, other, files):
    for file in files:
      if(other.db[file]['md5'] != 'xxx'): #don't update a null md5 
        self.db[file]['md5'] = other.db[file]['md5']                           
      else:
        print 'warning: MD5: %s isnt defined' % file  

      self.db[file]['time'] = other.db[file]['time']              
      self.db[file]['size'] = other.db[file]['size']


#Database plus local filesystem access
class DBRLocalEnv (DBREnv):
  def __init__(self, location):
    DBREnv.__init__(self, location)
    #load up local files...        
    self.db = dbrutils.scanenv()

  def verify(self, files):
    #should assert that the files are in the local DB.
    localfiles = set(self.db.keys())
    if(localfiles.issuperset(files)):
      md5s = dbrutils.generateMD5s(files)
      for file in files:
        self.db[file]['md5'] = md5s[file]['md5']

class DBRNewLocalEnv (DBRLocalEnv):
  def __init__(self, location):
    DBRLocalEnv.__init__(self, location)
    #load up local files...            
    hashes = glob.glob(os.path.join(dbrutils.patchpath(),'*.md5'))
    for file in hashes:
      print 'Reading: %s\n' % file
      dbrutils.gethashes(self.db, file, False)

  def save(self):
    filename = os.path.join(self.location,dbrutils.defaultdb())
    print 'Saving %s' % filename 
    dbrbaseline.writedb(self.db,filename)

        

    
#zipped files, contains MD5s.   
class DBRZippedEnv (DBREnv):
  def __init__(self, location):
    DBREnv.__init__(self, location)
    #load up zip MD5 and stuff
    self.db = dbrutils.getzippedDB(self.location)        
      
#Database, but no filesystem access
class DBRBaselineEnv (DBREnv):
  def __init__(self, location):
    DBREnv.__init__(self, location)
    #load up database...        
    filename = os.path.join(self.location,dbrutils.defaultdb())
    print 'Loading %s' % filename 
    self.db = dbrbaseline.readdb(filename)

  def save(self):
    filename = os.path.join(self.location,dbrutils.defaultdb())
    print 'Saving %s' % filename 
    dbrbaseline.writedb(self.db,filename)

class DBRPatchedBaselineEnv (DBRBaselineEnv):
  patches = []
  baseline = []
  def __init__(self, location):
    DBRBaselineEnv.__init__(self, location)
    #load up patches...        
    if(len(self.db) > 0):
      self.baseline = self.db      
      self.patches = dbrpatch.loadpatches(os.path.join(self.location,dbrutils.patchpath()))
      self.db = dbrpatch.createpatchedbaseline(self.baseline,self.patches)

  def save(self):
      self.baseline = dbrpatch.updatebaseline(self.baseline, self.db)
      self.patches = dbrpatch.updatepatches(self.patches, self.db)
      dbrpatch.savepatches(self.patches)
      self.db = self.baseline
      DBRBaselineEnv.save(self)
      
          
class CBREnv (DBREnv): # placeholder for handling CBR components...
  def __init__(self, location):
    DBREnv.__init__(self, location)


#comparison results...
class DBRCompResults:
  added = set()
  removed = set()
  touched = set()
  changed = set()
  unknown = set()
  def __init__(self, added, removed, touched, changed, unknown):
    #Should probably assert that these are disjoint.
    self.added = added
    self.removed = removed
    self.touched = touched
    self.changed = changed
    self.unknown = unknown
     
  def printdetail(self):
    for file in sorted(self.added):
      print 'added:', file
    for file in sorted(self.removed):
      print 'removed:', file
    for file in sorted(self.changed):
      print 'changed:', file
    for file in sorted(self.unknown):
      print 'unknown:', file
    
  def printsummary(self):
    if(len(self.added | self.removed | self.changed | self.unknown)):
      print 'status: dirty'
    else:
      print 'status: clean' 



class DBRFilter:
  info = ''
  def __init__(self):
    self.info = 'null filter'
  def filter(self, results):
    return results

class DBRFileFilter (DBRFilter):
  filename = ''
  def __init__(self, filename):
    DBRFilter.__init__(self)
    self.info = 'file filter'
    self.filename = filename
    self.files = dbrutils.readfilenamesfromfile(self.filename)
#    for file in sorted(self.files):
#      print file
     
  def filter(self, results):
    return DBRCompResults(results.added & self.files, results.removed & self.files, results.touched & self.files, results.changed & self.files, results.unknown & self.files)