#
# File:: vsutility.rb
# 
# Shared class functions for parsing, loading and creating
# 	Visual Studio projects.  Commonly accessible to all generators.
#
# Author:: Kevin Weinberg <kevin.weinberg@rockstarsandiego.com
# Date:: 22 September 2010
#
#
require 'pipeline/os/path'
require 'pipeline/os/file'
require 'xml'

module Pipeline

module ProjBuild

class VSUtility
	
	def VSUtility.create_guid( guid_filename, p4 )
	
		#If the GUID file does not exist, attempt to create it and add it to Perforce.
		if File.exists?(guid_filename) == false
		
			print "Creating new .guid file #{guid_filename}...\n"
			system("#{Globals::instance().toolsbin}\\coding\\uuidgen.exe -o#{guid_filename}")
			full_path = File.expand_path(guid_filename)
			
			if p4.nil? == false
				puts "p4 Adding #{full_path}"
				p4.run_add(full_path)
			end
			
			#Verify that the guid file has been created.  Otherwise, we have failed to create this project properly.
			if File.exists?(guid_filename) == false
				RageProjBuilderLoader.log.error("#{guid_filename} does not exist.  Can not generate project file!")
				return nil
			end	
		end
		guid = "#{File.readlines(guid_filename)[0]}"
		guid.chomp!		#Remove whitespace and newlines from the guid.
		guid = "{#{guid.upcase}}"
		
		return guid
	end
	
	def VSUtility.create_guid()
	
		temp_file = OS::Path.combine(Globals::instance().toolstemp, "temp.guidx")
		system("#{Globals::instance().toolsbin}\\coding\\uuidgen.exe -o#{temp_file}")
		
		guid = "#{File.readlines(temp_file)[0]}"
		guid.chomp!		#Remove whitespace and newlines from the guid.
		guid = "{#{guid.upcase}}"
		
		guid
	end
	
	#Parses the XML-formatted GUID file for particular information to generate
	#the project file.
	#
	def VSUtility.get_guid( guid_filename, path )
	
		#If the GUID file does not exist, attempt to create it and add it to Perforce.
		doc = nil
		if File.exists?(guid_filename) == false
		
			#Create the GUID file template.
			doc = XML::Document.new()		
			doc.encoding = XML::Encoding::UTF_8   #Used to create the proper XML header.
		
			project_node = XML::Node.new("Project")
			doc.root = project_node
			
			filters_node = XML::Node.new("Filters")
			project_node << filters_node

		else
		
			parser = XML::Parser.file(guid_filename)
			doc = parser.parse
		end
		
		filter_node = doc.root.find_first("Filters/Filter[@Path='#{path}']")
		
		guid = nil
		if filter_node == nil
			
			guid = create_guid()
			
			#Create this node and update the .guidx file.
			filters_node = doc.root.find_first("Filters")
			
			if filters_node == nil
				filters_node = XML::Node.new("Filters")
				doc.root << filters_node
			end
			
			new_filter_node = XML::Node.new("Filter")
			new_filter_node.attributes["Path"] = path
			new_filter_node.attributes["GUID"] = guid
			
			filters_node << new_filter_node
			
			#Save this XML and then convert it to a human-readable XML for easier differentiating.
			doc.save(guid_filename)
			VsXml::convert_to_vsxml(guid_filename, guid_filename, true)
		else
			
			#Parse it.
			guid = filter_node.attributes["GUID"]
		end
		
		return guid
	end
	
	WINDOWS_32_BIT_PLATFORM_NAME = "Win32"
	WINDOWS_64_BIT_PLATFORM_NAME = "x64"
	XBOX_360_PLATFORM_NAME = "Xbox 360"
	PLAYSTATION_3_PLATFORM_NAME = "Win32"  #Note that we build the Win32 platform specifically for the PS3, which has its own configurations.
	PLAYSTATION_3_PLATFORM_NAME_VS2010 = "PS3"  # DW now supported  in VS2010
	PSP2_PLATFORM_NAME = "Win32"  #Note that we build the Win32 platform specifically for the PSP2, which has its own configurations.
	PSP2_PLATFORM_NAME_VS2010 = "PSP2"
	def VSUtility.get_platform_name( platform, vs2010 = false )
	
		platform_name = case platform
		when :win32
			WINDOWS_32_BIT_PLATFORM_NAME
		when :win64
			WINDOWS_64_BIT_PLATFORM_NAME
		when :xbox360
			XBOX_360_PLATFORM_NAME
		when :ps3
			if vs2010==true
				PLAYSTATION_3_PLATFORM_NAME_VS2010
			else
				PLAYSTATION_3_PLATFORM_NAME				
			end
		when :psp2
			if vs2010==true
				PSP2_PLATFORM_NAME_VS2010
			else
				PSP2_PLATFORM_NAME				
			end
		else
			"#{platform.to_s}"
		end
	
		platform_name
	end

	def VSUtility.create_project_configuration_configuration( platform, target, vs2010 = false )
		if platform==:ps3
			if (vs2010==true)
				return "#{target}"
			else
				return "SN PS3 SNC #{target}"
			end
		end
		target.to_s
	end

	def VSUtility.create_config_name( platform, target, vs2010 = false  )
	
		config_name = case platform
		when :win32
			"#{target}|#{WINDOWS_32_BIT_PLATFORM_NAME}"
		when :win64
			"#{target}|#{WINDOWS_64_BIT_PLATFORM_NAME}"
		when :xbox360
			"#{target}|#{XBOX_360_PLATFORM_NAME}"
		when :ps3
			if vs2010==true
				"#{target}|#{PLAYSTATION_3_PLATFORM_NAME_VS2010}"
			else
				"SN PS3 SNC #{target}|#{PLAYSTATION_3_PLATFORM_NAME}"				
			end		
			
		when :psp2
			if vs2010==true
				"#{target}|#{PSP2_PLATFORM_NAME_VS2010}"
			else
				"SN PSP2 SNC #{target}|#{PSP2_PLATFORM_NAME}"			
			end
		else
			"#{target}|#{platform.to_s}"
		end
	
		config_name
	end	
		
	def VSUtility.create_config_type( config )
	
		return "1" if config == nil
		return "1" if config.xml_data == nil
		return "1" if config.xml_data.attributes["type"] == nil
	
		type = config.xml_data.attributes["type"].intern
	
		ret = case type
		
		when :library
			"4"
		when :dll
			"2"
		when :exe
			"1"
		else "1"
		end
		
		ret
	end
	
	APPLICATION = "Application"
	DLL = "DynamicLibrary"
	LIBRARY = "StaticLibrary"
		
	def VSUtility.create_2010_config_type( config )
		
		return LIBRARY if config == nil
		return LIBRARY if config.xml_data == nil
		return LIBRARY if config.xml_data.attributes["type"] == nil
	
		type = config.xml_data.attributes["type"].intern
	
		ret = case type
		
		when :library
			LIBRARY
		when :dll
			DLL
		when :exe
			APPLICATION
		else 
			APPLICATION
		end
		
		ret
	end
	
	MULTIBYTE = "MultiByte"
	UNICODE = "Unicode"
	NOTSET = "NotSet"
	
	def VSUtility.create_2010_character_set( config )
		return MULTIBYTE if config == nil
		return MULTIBYTE if config.xml_data == nil
		return MULTIBYTE if config.xml_data.attributes["character_set"] == nil
		
		character_set = config.xml_data.attributes["character_set"].intern
		
		ret = case character_set
		
		when :notset
			NOTSET
		when :unicode
			UNICODE
		when :multibyte
			UNICODE
		else 
			MULTIBYTE
		end
	
		ret
	end

  def VSUtility.create_2010_platform_toolset( config, platform_sym, target_sym )
		return "SNC" if platform_sym.to_s.downcase == "ps3"
	end

  def VSUtility.create_2010_exceptions_and_rtti( config, platform_sym, target_sym )
		"NoExceptsWithRtti" if platform_sym.to_s.downcase == "ps3"
	end

	def VSUtility.get_library_dependencies( config, target_sym )
	
		#Determine the list of library dependencies.
		additional_deps = Array.new()
		libs_node = config.find("libs/lib")
			
		if libs_node != nil then
		
			libs_node.each { |lib_node|
				
				configurations_node = lib_node.find("configuration")
				
				if configurations_node.size > 0
					
					configurations_node.each { |config_node|
					
						if( target_sym.eql?(config_node["name"]) )
						
							additional_deps.push(lib_node["path"])
							break
						end
					}
				
				else
					additional_deps.push(lib_node["path"])
				end
			}		
		end
		
		additional_deps
	end
	
	def VSUtility.get_force_includes( config )
		
		i = 0
		
		forceinclude_nodes = config.xml_data.find("forceincludes/forceinclude")
		# DHM and RMS 2010/11/22 - don't do a seperate query to get the size for array preallocation, 
		# as libxml_ruby has issues without freeing the node set explicitly.
		forceincludes = Array.new(forceinclude_nodes.size) 
	
		forceinclude_nodes.each do |forceinclude_node|
			
			forcei = nil
			forcei = i = forceinclude_node["order"].to_i if forceinclude_node["order"] != nil

			if forceincludes[i] != nil then
			
				0.upto(forceincludes.size - 1) { |j|
				
					if forceincludes[j] == nil then
					
						i = j 
						break
					end
				}
			end
					
			if forcei then
			
				forceincludes[i] = forceincludes[forcei]
				forceincludes[forcei] = forceinclude_node["path"]
			else
					
				forceincludes[i] = forceinclude_node["path"]
			end
			
			i = i + 1
		end
		forceinclude_nodes = nil
			
		forceincludes	
	end
end

end #module ProjBuild

end #module Pipeline