#*******************************************************************************
# Usage:
#
#	ruby p4conf.rb  --apidir=<path to api>
#
#*******************************************************************************
require 'mkmf'
require 'rbconfig'
require "getoptlong"
require "fileutils"

class ApiVersion
	def initialize( major, minor = nil )
		if( major.kind_of?( String ) && ! minor )
			if( major =~ /(\d+)\.(\d+)/ )
				major = $1
				minor = $2
			else
				raise( "Bad API version: #{major}" )
			end
		end

		@major 	= major.to_i
		@minor	= minor.to_i
		@type   = nil
	end

	def set_type( type )
		if( type.kind_of?( String ) )
			@type = type
		end
	end

	attr_reader :major, :minor, :type

	include Comparable

	def to_s
		if( @type and not @type.empty? )
			"#{major}.#{minor}.#{@type.upcase}"
		else
			"#{major}.#{minor}"
		end
	end

	def to_i
		major << 8 | minor
	end

	def <=>( other )
		hi = @major <=> other.major
		lo = @minor <=> other.minor

		return hi == 0 ? lo : hi
	end
end

#*******************************************************************************
# Prompt the user for something
#*******************************************************************************
def prompt( str, testproc )
	while true
		print( str + ": " )
		val = $stdin.gets.chomp
		break if ( testproc.call( val ) )
	end
	return val
end

#*******************************************************************************
# Find out as much info about the platform as we can. Ideally we want to
# determine the OS name, version and CPU architecture so we can decide
# which compiler flags should be used for the Perforce API for that
# platform.
#*******************************************************************************
def probe_platform

	#
	# Work out the target OS, Version, and Platform
	#
	$p4osplat = CONFIG[ 'arch' ].split( /-/ )[ 0 ].upcase
	$p4osname = CONFIG[ 'arch' ].split( /-/ )[ 1 ].upcase
	$p4osname = $p4osname.gsub( /MSWIN32(_\d+)?/, "NT" )
	$p4osname = $p4osname.split( "-" ).shift
	$p4osver  = ""

	# Now work out the OS version
	if( $p4osname == "NT" )
		$p4osver = ""
	elsif( $p4osname =~ /FREEBSD([0-9]+)/ )
		$p4osname = "FREEBSD"
		$p4osver = $1
	elsif( $p4osname =~ /DARWIN([0-9]+)/ )
		$p4osname = "DARWIN"
		$p4osver = $1
	elsif( $p4osname =~ /AIX(5)\.(\d)/ )
		# AIX osname looks like "aix5.3.0.0"
		$p4osname = "AIX"
		$p4osver = $1 + $2
	elsif( $p4osname =~ /SOLARIS2\.(\d+)/ )
		$p4osname = "SOLARIS"
		$p4osver = $1
	else
		# Try running a 'uname -r' to work out the version
		begin
			$p4osver=`uname -r`.chomp
			ver_re = /^(\d+)\.(\d+)/
			md = ver_re.match( $p4osver )
			if( md )
				maj = md[1].to_i
				min = md[2].to_i
				$p4osver = maj.to_s + min.to_s
			end
		rescue
			# Nothing - if it failed, it failed.
		end
	end

	# On Mac OSX, fix the build to 64 bit arch
	$p4osplat = "X86_64" if( $p4osname == "DARWIN" )

	# Translate Ruby's arch names into Perforce's. Mostly the same so
	# only the exceptions are handled here.
	if( $p4osplat =~ /^I.86$/ )
		$p4osplat = "X86"
	elsif( $p4osplat =~ /^AMD64$/ )
		$p4osplat = "X86_64"
	elsif( $p4osplat == "POWERPC" )
		$p4osplat = "PPC"
	end
end

def uname_platform
	plat = "UNKNOWN"
	begin
		plat = `uname -p`
		plat = plat.chomp.upcase
	rescue
		# Nothing - if it failed, it failed.
	end
	plat
end

#*******************************************************************************
# Allow the user to override our guesses as to the platform and provide
# an explicit API build version.
#*******************************************************************************
def override_platform( plat )

	archs = %w{ x86 amd64 ppc sparc arm axp }

	# Build the regular expression we're going to use, first as a string
	plat_re = '(\D+)(\d+)?('
	plat_re += archs.join( '|' )
	plat_re += ')?'

	# Now convert to a regexp
	plat_re = Regexp.new( plat_re )

	if( md = plat_re.match( plat ) )
		$p4osname = md[ 1 ].upcase
		$p4osver  = md[ 2 ] || ""
		$p4osplat = ( md[ 3 ] || "" ).upcase
	end
end

#*******************************************************************************
# Set platform specific compile options
#*******************************************************************************
def set_platform_cflags
	$CFLAGS += "-DOS_#{$p4osname} "
	$CFLAGS += "-DOS_#{$p4osname}#{$p4osver} "
	$CFLAGS += "-DOS_#{$p4osname}#{$p4osver}#{$p4osplat} "

	if( $p4osname == "NT" )
		$CFLAGS += "/DCASE_INSENSITIVE "
	end

	if( $p4osname == "MINGW32")
		$CFLAGS += "-DOS_NT -DCASE_INSENSITIVE "
	end

	if( $p4osname == "SOLARIS" )
		$CFLAGS += "-Dsolaris "
	end

	if( $p4osname == "DARWIN" )
		#	Only build for 64 bit if we have more than one arch defined in CFLAGS
		$CFLAGS.slice!( "-arch i386" )
		$CFLAGS.slice!( "-arch ppc" );
		$CFLAGS += "-DCASE_INSENSITIVE "
	end
end

#*******************************************************************************
# Set platform specific build options
#*******************************************************************************
def set_platform_opts

	#***************************************************************************
	# C++ programs should be linked with g++ not with gcc. mkmf doesn't get that
	# right, so we have to hack it a little here. This particularly affects
	# gcc 3.x users as older gcc versions didn't mind too much. Since mkmf is
	# pretty convoluted it seems the safest way to ensure that g++ is used is
	# to update the LDSHARED and CC values directly
	#***************************************************************************

	# Expand any embedded variables (like '$(CC)')
	CONFIG[ 'CC' ] 	 = Config::CONFIG[ 'CC' ]
	CONFIG[ 'LDSHARED' ] = Config::CONFIG[ 'LDSHARED' ]

	# Now ensure we're using g++ instead of gcc
	CONFIG[ 'CC' ].sub!( /gcc/, "g++" )
	CONFIG[ 'LDSHARED' ].sub!( /gcc/, "g++" )
	CONFIG[ "CXX" ] = CONFIG[ "CC" ] unless CONFIG.has_key?( "CXX" )

	# O/S specific oddities

	if ( $p4osname == "CYGWIN" && $p4gccver == 2 )
		CONFIG[ "CC" ] = "gcc-2"
		CONFIG[ "CXX" ] = "g++-2"
		CONFIG[ "LDSHARED" ].gsub!( /g\+\+/, "g++-2" )
	elsif ( $p4osname == "DARWIN" && $p4gccver == 2 )
		CONFIG[ "CC" ] = "gcc2"
		CONFIG[ "CXX" ] = "g++2"
		CONFIG[ "LDSHARED" ].sub!( /^cc/, "g++2" )
	elsif ( $p4osname == "DARWIN" )
		CONFIG[ "LDSHARED" ] = CONFIG[ "CXX" ] + " -bundle"
	elsif ( $p4osname == "FREEBSD" || $p4osname == "LINUX" )
		# FreeBSD 6 and some Linuxes use 'cc' for linking by default. The
		# gcc detection patterns above won't catch that, so for these
		# platforms, we specifically convert cc to c++.
		CONFIG[ "LDSHARED" ].sub!( /^cc/, "c++" )
	elsif( $p4osname == "MINGW32" )
		# When building with MinGW we need to statically link libgcc
		CONFIG[ "LDSHARED" ] = CONFIG[ "LDSHARED" ] + " -static-libgcc -static-libstdc++"
	end
end

#*******************************************************************************
# Use platform libs. Call *before* adding the API libs to preserve linking
# order.
#*******************************************************************************
def use_platform_libs
	if ( $p4osname == "SOLARIS" )
		osver = `uname -r`
		osver.gsub!( /5\./, "2" )
		if ( osver == "25" )
			$LDFLAGS += "/usr/ucblib/libucb.a "
		end
		use_lib( "nsl" )
		use_lib( "socket" )
	elsif ( $p4osname == "NT" )
		use_lib( "advapi32" )
		use_lib( "wsock32" )
		use_lib( "kernel32" )
		use_lib( "oldnames" )
	elsif( $p4osname == "CYGWIN" )
		# Clear out the bogus libs on cygwin.
		CONFIG[ "LIBS" ] = ""
	elsif( $p4osname == "DARWIN" && $p4osver.to_i >= 8 )
		#	Only build for 64 bit if we have more than one arch defined in CFLAGS
		$LDFLAGS.slice!( "-arch i386" )
		$LDFLAGS.slice!( "-arch ppc" );
		$LDFLAGS += " -framework Carbon"
	end
end

#*******************************************************************************
# Set directory for the Perforce API
#*******************************************************************************
def set_apidir( path, sslpath )
	libdir = path + "/lib"
	libdir = [ File.directory?( libdir ) ? libdir : path ]
	libdir.push( sslpath )	unless( sslpath.nil? or sslpath.empty? )

	hdrdir = path + "/include/p4"
	hdrdir = File.directory?( hdrdir ) ? hdrdir : path

	# This bit's real ugly... Ruby's mkmf.rb seems to have a very strange idea
	# about link order. It puts the default library paths ahead of thos suppled
	# by the user at runtime. When library names clash that doesn't help
	# anyone. So, we mess with DEFLIBPATH here, as well as LIBPATH in the hope
	# that a belt-and-braces approach will do the trick on all platforms.
	# Sadly, DEFLIBPATH doesn't always exist so we have to test for it.
	$DEFLIBPATH = [ libdir ] | $DEFLIBPATH if $DEFLIBPATH
	$LIBPATH 	= [ libdir ] | $LIBPATH
	$DEFLIBPATH.flatten!
	$LIBPATH.flatten!

	$CFLAGS += " -I#{hdrdir} "
end

#*******************************************************************************
# Get the version of the Perforce API in a directory
#*******************************************************************************
def get_api_version( dir )
	#
	# 2007.2 and later APIs put the Version file in the 'sample'
	# subdirectory. Look there if we can't find it in the API root
	#
	ver_file = dir + "/Version"
	unless File.exists?( ver_file )
		ver_file = dir + "/sample/Version"
		return nil unless File.exists?( ver_file )
	end

	re = Regexp.new( '^RELEASE = (\d+)\s+(\d+)\s+(\w*\S*)\s*;' )
	rp = Regexp.new( '^PATCHLEVEL = (\d+)' )
	apiver = nil
	File.open( ver_file, "r" ) do
		|f|
		f.each_line do
			|line|
			if md = re.match( line )
				apiver = ApiVersion.new( md[ 1 ],  md[ 2 ] )
				apiver.set_type( md[ 3 ] )
			elsif md = rp.match( line )
				$apipatch = md[ 1 ]
			end
		end
	end
	puts( "Found #{apiver} Perforce API in #{dir}" )
	return apiver
end

#*******************************************************************************
# Function to check that the version of the API used is digestible
#*******************************************************************************
def check_api_version( ver )
	return true if ver == $TARGET_API_VERSION

	if( ver != $TARGET_API_VERSION )
		puts <<EOS

This version of P4Ruby was designed for use with the #{$TARGET_API_VERSION}
release of the Perforce C++ API. Using it with other releases may not work,
and is not supported.

EOS
		print( "Do you wish to continue anyway (y/n): " )
		answer = $stdin.gets.chomp
		return false unless answer == "y"
	end
	true
end

def check_ruby_version
	if Config::CONFIG['MAJOR'] == '1' &&
	(Config::CONFIG[ 'MINOR'] == '8' || Config::CONFIG[ 'MINOR'] == '9')
		return true
	end

	puts <<EOS

Use of this version of P4Ruby with versions of Ruby other than the 1.8 or
1.9 series is not supported.

EOS
	print( "Do you wish to continue anyway (y/n): " )
	answer = $stdin.gets.chomp
	return false unless answer == "y"
	true
end

#*******************************************************************************
# function for generating a correctly formatted #define string
#*******************************************************************************
def define( macro, value, string=true )
	if( string )
		%Q{#define #{macro}\t"#{value}"}
	else
		%Q{#define #{macro}\t#{value}}
	end
end

#*******************************************************************************
#* Write the extconf.h file
#*******************************************************************************
def write_extconf_h
	File.open( "extconf.h", "w" ) do
		|ch|
		ch.puts( define( "P4APIVER_STRING",	$apiver ) )
		ch.puts( define( "P4APIVER_ID", 	$apiver.to_i, false ) )
		ch.puts( define( "P4OSNAME",		$p4osname ) )
		ch.puts( define( "P4OSPLAT",		$p4osplat ) )
		ch.puts( define( "P4OSVER",		$p4osver ) )
		ch.puts( define( "P4CFLAGS", 		$CFLAGS.gsub( '"', '\"' ) ) )
		ch.puts( define( "P4LIBPATH",		$LIBPATH.join( ":" ) ) )
		ch.puts( define( "P4LIBS",   		$libs ) )
		ch.puts( define( "ID_OS",		$p4osname + $p4osver + $p4osplat ) )
		ch.puts( define( "ID_REL",		$p4ruby_version.join( "." ).upcase ) )
		ch.puts( define( "ID_PATCH",		$p4ruby_patchlevel, true ) )
		ch.puts( define( "ID_Y",		$p4ruby_date[ 0 ] ) )
		ch.puts( define( "ID_M",		$p4ruby_date[ 1 ] ) )
		ch.puts( define( "ID_D",		$p4ruby_date[ 2 ] ) )
		ch.puts( define( "ID_API",		$apiver ) )
		ch.puts( define( "ID_API_PATCH",	$apipatch ) )
	end
end

#*******************************************************************************
# Add a Perforce API library making sure it's properly named on NT
#*******************************************************************************
def api_lib( lib )
	rlib = lib
	rlib = "lib" + lib if ( $p4osname == "NT" )
	use_lib( rlib )
end

#*******************************************************************************
# Add a library to the link command bypassing lame have_library/find_library
# which utterly suck for C++ libs.
# NOTE: Add libs in *reverse* order.
#*******************************************************************************
def use_lib( lib )
	$libs = append_library( $libs, lib )
end

#*******************************************************************************
# Function to write the makefile itself. This is mostly a wrapper around
# mkmf's create_makefile(), but due to some deficiencies in mkmf w.r.t C++
# sources, we occasionally have to edit the makefile
#*******************************************************************************
def write_makefile( name )
	create_makefile( name )
	if ( CONFIG[ "CXX" ] )
		# Then we need to add a definition of CXX to the makefile
		# or the build will fail on some platforms (Cygwin at least).
		File.unlink( "Makefile.tmp" ) if File.exists?( "Makefile.tmp" )
		File.rename( "Makefile", "Makefile.tmp" )
		inmf = File.open( "Makefile.tmp" )
		outmf = File.open( "Makefile", "w+" )
		seen = false
		inmf.each do
			|line|
			if ( !seen && line =~ /^CC = / )
				outmf.puts( "CXX = " + CONFIG[ "CXX" ] )
				seen = true
			end
			outmf.puts( line )
		end
		inmf.close
		outmf.close
		File.unlink( "Makefile.tmp" )
	end

end

#*******************************************************************************
# Identify P4Ruby Version and date from the Version file
#*******************************************************************************
def identify_p4ruby
	File.open( "Version" ) do
		|f|
		f.each_line do
			|line|
			line = line.chomp
			if( line =~ /^RELEASE\s*=\s*(\d+\s+\d+\s+\w*\S*)\s*;/ )
				$p4ruby_version = $1.split( / / )
			elsif( line =~ /^PATCHLEVEL\s*=\s*(\d+)/ )
				$p4ruby_patchlevel = $1.to_i
			elsif( line =~ /^SUPPDATE\s*=\s*([0-9 ]+)/ )
				$p4ruby_date = $1.split( / / )
			end
		end
	end
end

#*******************************************************************************
# Copy version file from P4 tree if it exists.
#*******************************************************************************
def copy_version
	v = '../p4/Version'
	if File.exists?( v )
		FileUtils.cp( v, 'Version' )
		FileUtils.chmod( 0644, 'Version' )
	end
end

#*******************************************************************************
# Setup SSL lib linkage
#*******************************************************************************
def ssl_lib
	#	Check the API is at least 2012.1 - earlier versions don't support
	#	encryption, so we shouldn't even try to link.
	return if( $apiver < ApiVersion.new( 2012, 1 ) )

	if( $sslpath.nil? )
		api_lib( "p4sslstub" )
	else
		#	The SSL lib names are different on Windows, so we
		#	need to check what platform we are building on.
		if( $p4osname =~ /NT/ )
			plat = $p4osplat == "X86" ? "32" : "64"
			$libs = append_library( $libs, "ssleay#{plat}" )
			$libs = append_library( $libs, "libeay#{plat}" )

		elsif( $p4osname =~ /MINGW/ )
			$libs = append_library( $libs, "gdi32" )
			$libs = append_library( $libs, "crypto" )
			$libs = append_library( $libs, "ssl" )
		else
			$libs = append_library( $libs, "crypto" )
			$libs = append_library( $libs, "ssl" )
		end
	end
end

#*******************************************************************************
# Make any necessary changes to the Makefile.
#*******************************************************************************
def patch_makefile()
	return unless $p4osname == "NT"

	# On Windows, 'make install' can fail if any of the files are read-only.
	# This is because install tries to set the modtime on the file using utime()
	# and utime only works if a file is writable. This just makes install not
	# try to set the time.
	#
	# On Windows, we assume we're using VC++ 2005 or newer and that the
	# manifest for the DLL must be updated. This adds that command into
	# the Makefile as Ruby doesn't do it for us.
	i = File.open( "Makefile", "r" )
	o = File.open( "Makefile.tmp", "w" )
	i.each_line do
		|line|
		if( line =~ /^INSTALL_PROG/ or line =~ /^INSTALL_DATA/ )
			line.sub!( /vpm/, "vm" )
		elsif( line =~ /^\t\$\(LDSHARED\)/ )
			line += "\tmt -nologo -manifest $(DLLIB).manifest -outputresource:$(DLLIB);2"
		end
		o.write( line )
	end
	i.close
	o.close
	File.unlink( "Makefile" )
	File.rename( "Makefile.tmp", "Makefile" )
end

#*******************************************************************************
# Start of main functionality
#*******************************************************************************

#
# Maximum version of the Perforce API this build of P4Ruby knows how to
# work with
#
$TARGET_API_VERSION = ApiVersion.new( 2012, 2 )

opts = GetoptLong.new(
[ "--apidir",	"-d", 	GetoptLong::REQUIRED_ARGUMENT ],
[ "--ssl",	GetoptLong::OPTIONAL_ARGUMENT ]
)

$apidir = nil
$apiver = nil
$apipatch = nil
$apibuild = nil
$apitype  = nil
$p4ruby_ver = nil
$p4ruby_date = nil
$p4ruby_patchlevel = nil
$sslpath = nil
$withssl = false

opts.each do
	|opt,arg|
	if ( opt == "--apidir" )
		$apidir = File.expand_path( arg )
	elsif ( opt == "--ssl" )
		$sslpath = arg.empty? ? arg : File.expand_path( arg )
	end
end

copy_version

puts( "" )
puts( "Starting to configure P4/Ruby for building" )
puts( "" )

#
# Guess the platform we're on, and then allow the user to override our
# guesswork if necessary
#
probe_platform()
override_platform( $apibuild )

#
# If the user has not supplied the api directories or apiver we prompt for them
#
dirproc = Proc.new {
	|dir|
	dir = File.expand_path( dir )
	if ( ! File.directory?( dir ) )
		puts( "No such directory. Try again" )
		false
	else
		true
	end
}

if ( ! $apidir )
	$apidir = prompt( "Enter the path to the Perforce API", dirproc )
	$apidir = File.expand_path( $apidir )
end

#
# Read the Version file in the API directory to find the API version string
# and add this to the build environment
#

#
# If we failed to work this out, we have to ask the user.
#
verproc = Proc.new {
	|ver|
	if( ver =~ /(\d+)\.(\d+)/ )
		true
	else
		puts( "Not a valid Perforce version. Try again." )
		false
	end
}

$apiver = get_api_version( $apidir )
if( !$apiver )
	while( ! $apiver )
		$apiver = prompt( "Enter the version of the Perforce API", verproc )
	end
	$apiver = ApiVersion.new( $apiver )
end

#
# Check that the version of the API is one we can cope with, or that the
# user wants to punt.
#
exit( 1 ) unless check_ruby_version
exit( 1 ) unless check_api_version( $apiver )

set_apidir( $apidir, $sslpath )
set_platform_opts()
set_platform_cflags()
use_platform_libs()
identify_p4ruby

# Perforce API libraries - in reverse order
ssl_lib
api_lib( "supp" )
api_lib( "rpc" )
api_lib( "client" )

#
# OK, now we know what we're going to do, let's tell the user
#
puts <<EOS

P4/Ruby Configuration Summary
-----------------------------

Using Perforce API Version: #{$apiver}
API headers and libs from : #{$apidir}
OS name                   : #{$p4osname}
OS version                : #{$p4osver}
Platform                  : #{$p4osplat}
CFLAGS                    : #{$CFLAGS}
LIBPATH                   : #{$LIBPATH.join(":")}
libs                      : #{$libs}

EOS

puts( "Creating extconf.h" )
write_extconf_h
write_makefile( "P4" )
patch_makefile