# Copyright (c) MetaCommunications, Inc. 2003-2005
#
# Distributed under the Boost Software License, Version 1.0. 
# (See accompanying file LICENSE_1_0.txt or copy at 
# http://www.boost.org/LICENSE_1_0.txt)

import difflib
import os
import re
import shutil
import string
import sys


def scan_for_test_cases():
    return [ os.path.join( "test-cases", x ) for x in os.listdir( "test-cases" ) if x != "CVS" ]

def clean_dir( dir ):
    if os.path.exists( dir ):
        shutil.rmtree( dir )
    os.makedirs( dir )

def system( commands ):
    if sys.platform == 'win32':
        f = open( 'tmp.cmd', 'w' )
        f.write( string.join( commands, '\n' ) )
        f.close()
        rc = os.system( 'tmp.cmd' )
        os.unlink( 'tmp.cmd' )
        return rc
    else:
        rc = os.system( '&&'.join( commands ) )
        return rc

def checked_system( commands, valid_return_codes = [ 0 ] ):
    rc = system( commands ) 
    if rc not in [ 0 ] + valid_return_codes:
        raise Exception( 'Command sequence "%s" failed with return code %d' % ( commands, rc ) )
    return rc

def list_recursively( dir ):
    r = []
    for root, dirs, files in os.walk( dir, topdown=False ):
        root = root[ len( dir ) + 1 : ]
        r.extend( [ os.path.join( root, x ) for x in dirs ] )
        r.extend( [ os.path.join( root, x ) for x in files ] )

    return r

def find_process_jam_log():
    root = "../../../"
    
    for root, dirs, files in os.walk( os.path.join( root, "bin.v2" ), topdown=False ):
        if "process_jam_log.exe" in files:
            return os.path.abspath( os.path.normpath( os.path.join( root, "process_jam_log.exe" ) ) )
        if "process_jam_log" in files:
            return os.path.abspath( os.path.normpath( os.path.join( root, "process_jam_log" ) ) )
    return None

def process_jam_log( executable, file, locate_root, results_dir ):
    args = []
    args.append( executable )
    # args.append( '--echo' )
    args.append( '--create-directories' )
    args.append( '--v2' )
    args.append( locate_root )
    args.append( '<' )
    args.append( file )

    cmd = " ".join( args )
    print "Running process_jam_log (%s)" % cmd
    checked_system( [ cmd ] )
    

def read_file( file_path ):
    f = open( file_path )
    try:
        return f.read()
    finally:
        f.close()

def remove_timestamps( log_lines ):
    return [ re.sub( "timestamp=\"[^\"]+\"", "timestamp=\"\"", x ) for x in log_lines ]    

def determine_locate_root( bjam_log ):
    locate_root = None
    f = open( 'bjam.log' )
    try:
        locate_root_re = re.compile( r'locate-root\s+"(.*)"' )
        for l in f.readlines():
            m = locate_root_re.match( l )
            if m:
                locate_root = m.group(1)
                break
    finally:
        f.close()
    return locate_root

def read_file( path ):    
    f = open( path )
    try:
        return f.read()
    finally:
        f.close()

def read_file_lines( path ):    
    f = open( path )
    try:
        return f.readlines()
    finally:
        f.close()

def write_file( path, content ):    
    f = open( path, 'w' )
    try:
        return f.write( content )
    finally:
        f.close()

def write_file_lines( path, content ):    
    f = open( path, 'w' )
    try:
        return f.writelines( content )
    finally:
        f.close()

        
def run_test_cases( test_cases ):
    process_jam_log_executable = find_process_jam_log()
    print 'Found process_jam_log: %s' % process_jam_log_executable
    initial_dir = os.getcwd()
    for test_case in test_cases:
        os.chdir( initial_dir )
        print 'Running test case "%s"' % test_case
        os.chdir( test_case )
        if os.path.exists( "expected" ):
            locate_root = determine_locate_root( 'bjam.log' )
            print 'locate_root: %s' % locate_root
            
            actual_results_dir = os.path.join( test_case, "actual" )
            clean_dir( "actual" )
            os.chdir( "actual" )
            root = os.getcwd()
            i = 0
            while 1:
                if i == 0:
                    bjam_log_file = 'bjam.log'
                else:
                    bjam_log_file = 'bjam.log.%0d' % i
                i += 1
                print 'Looking for %s' % bjam_log_file
                if not os.path.exists( os.path.join( '..', bjam_log_file ) ):
                    print '    does not exists'
                    break
                print '    found'
                write_file_lines(bjam_log_file.replace( 'bjam', 'bjam_' ), 
                                 [ x.replace( locate_root, root  ) for x in read_file_lines( os.path.join( '..', bjam_log_file ) ) ]  )
                
                process_jam_log( executable = process_jam_log_executable
                                 , results_dir = "."
                                 , locate_root = root 
                                 , file=bjam_log_file.replace( 'bjam', 'bjam_' ) )
            
            actual_content = list_recursively( "." )
            actual_content.sort()
            result_xml = []
            for test_log in [ x for x in actual_content if os.path.splitext( x )[1] == '.xml' ]:
                print 'reading %s' % test_log
                result = [ re.sub( r'timestamp="(.*)"', 'timestamp="xxx"', x ) for x in read_file_lines( test_log ) ]
                result_xml.extend( result )
                
            write_file_lines( 'results.xml', result_xml )
            os.chdir( '..' )
            assert read_file( 'expected/results.xml' ) == read_file( 'actual/results.xml' )
            os.chdir( '..' )
        else:
            raise '   Test case "%s" doesn\'t contain the expected results directory ("expected" )' % ( test_case )
        
run_test_cases( scan_for_test_cases() )
# print find_process_jam_log()