require 'xml'
require 'pipeline/coding/projbuild/project'
require 'pipeline/coding/projbuild/generators/vsshared'

module Pipeline

module ProjBuild

class VS2008VSSlnExporter < VSProjShared

	@@log = nil 

	def VS2008VSSlnExporter.log

		@@log = Log.new( 'vs2008vsslnexporter' ) if @@log == nil
		@@log
	end

	def initialize()
	
		@log = VS2008VSSlnExporter.log
		
		config = Pipeline::Config.instance
	
#		@p4 = SCM::Perforce.new()
#		@p4.port = config.sc_server
#		@p4.client = config.sc_workspace
#		@p4.user = config.sc_username
#		@p4.connect()
	end

	def export(path, project)

		path = VS2008Generator.get_solution_filename(path)
		
		#add_in_p4(path) as of yet adding is not supported - but I think it should be eventually.

		sln_guid = "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}"
		proj_build = ProjBuildData::instance()
				
		File.open(path,"w+") { |file|
		
			main_filename = VS2008Generator.get_project_filename(project.name)
			#identifying character sequence for a 2008 sln
		
			file.putc(0xef)
			file.putc(0xbb)
			file.putc(0xbf)		
			file.write("\n")
			file.write("Microsoft Visual Studio Solution File, Format Version 10.00\n")
			file.write("# Visual Studio 2008\n")			
			file.write("Project(\"#{sln_guid}\") = \"#{project.name}\", \"#{main_filename}\", \"#{project.guid}\"\n")
			file.write("\tProjectSection(ProjectDependencies) = postProject\n")
	
			dep_guids = ActiveSupport::OrderedHash.new()
			project.dep_guids.each { |dep_guid|
			
				dep_guids[dep_guid] = true
				dep_project = proj_build.dependent_projects[dep_guid]			
				file.write("\t\t#{dep_project.guid} = #{dep_project.guid}\n")
			}
						
			file.write("\tEndProjectSection\n")			
			file.write("EndProject\n")
			
			proj_build.dependent_projects.keys.each { |dep_guid|
			
				next if dep_guid == project.guid
				dep_project = proj_build.dependent_projects[dep_guid]

				filename = OS::Path.combine(dep_project.path,dep_project.name)							
				filename = OS::Path.dos_format(VS2008Generator.get_project_filename(filename))
								
				file.write("Project(\"#{sln_guid}\") = \"#{dep_project.name}\", \"#{filename}\", \"#{dep_project.guid}\"\n")
				file.write("EndProject\n")
			}
			
			file.write("Global\n")
			file.write("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n")
			
			
			proj_build.sln_platforms.each { |sln_platform,targets|

				targets.each { |sln_target,proj_cfg|
			
					platform_out = VSProjShared.get_platform_string(sln_platform)
					config = "#{sln_target}|#{platform_out}"
			
					file.write("\t\t#{config} = #{config}\n")
				}
			}			
			
			file.write("\tEndGlobalSection\n")
			
			file.write("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\n")
			proj_build.sln_platforms.each { |sln_platform,targets|
			
				targets.each { |sln_target,proj_cfgs|
										
					#First process the start up project.
					proj_cfg = proj_cfgs[project.guid]
					prj_cfg = VSUtility.create_config_name(proj_cfg.platform,proj_cfg.target)
					sln_cfg = "#{sln_target}|#{VSProjShared.get_platform_string(sln_platform)}"
					config_out = "#{project.guid}.#{sln_cfg}"
					
					file.write("\t\t#{config_out}.ActiveCfg = #{prj_cfg}\n")
					file.write("\t\t#{config_out}.Build.0 = #{prj_cfg}\n")
					
					#Process its dependent projects.
					proj_build.dependent_projects.keys.each { |guid|
				
						next if proj_cfgs[guid] == nil						
						proj_cfg = proj_cfgs[guid]
						
						prj_cfg = VSUtility.create_config_name(proj_cfg.platform,proj_cfg.target)
						sln_cfg = "#{sln_target}|#{VSProjShared.get_platform_string(sln_platform)}"
						config_out = "#{guid}.#{sln_cfg}"
				
						file.write("\t\t#{config_out}.ActiveCfg = #{prj_cfg}\n")
						
						if dep_guids[guid] or guid == project.guid then
						
							file.write("\t\t#{config_out}.Build.0 = #{prj_cfg}\n")
						end
					}
				}
			}
			
			file.write("\tEndGlobalSection\n")
			
			file.write("\tGlobalSection(SolutionProperties) = preSolution\n")
			file.write("\t\tHideSolutionNode = FALSE\n")
			file.write("\tEndGlobalSection\n")
			file.write("EndGlobal\n")
		}
		
		revert_unchanged(path)
		
		true
	end
end

class VS2008VSProjExporter < VSProjExporterShared

	@@log = nil 

	def VS2008VSProjExporter.log

		@@log = Log.new( 'vs2008vsprojexporter' ) if @@log == nil
		@@log
	end

	def initialize()
	
		@log = VS2008VSProjExporter.log
		@version = "2008"
	end
	
protected
	
	def create_project_node( project )

		xml_node = XML::Node.new("VisualStudioProject")
		xml_node.attributes["ProjectType"] = "Visual C++"
		xml_node.attributes["Version"] = "9.00"
		xml_node.attributes["Name"] = project.name
		xml_node.attributes["ProjectGUID"] = project.guid
		xml_node.attributes["Keyword"] = "Win32Proj"	
		xml_node.attributes["TargetFrameworkVersion"] = "131072"	
		
		xml_node
	end	
end

class VS2008VSProjLoader  < VSProjShared

	@@log = nil 

	def VS2008VSProjLoader.log

		@@log = Log.new( 'vs2008vsprojloader' ) if @@log == nil
		@@log
	end

	def initialize()
	
		@log = VS2008VSProjLoader.log
	end
	
	def import( path, project_path = nil )
	
		if File.exists?(path) == false then
	
			@log.debug("couldn't open #{path}")
			return false 
		end
	
		@log.debug("checking #{path} with vs2008 project loader")
	
		data = nil
	
		parser = XML::Parser.file(path)
		doc = parser.parse	
		
		if doc.root.attributes["Version"] != "9.00" then
		
			@log.debug("#{path} not in the correct format")
			return false 
		end
		
		strip_unused_info(doc)
		
		@log.debug("parsing #{path} with vs2008 project loader")
		
		@curr_project = Info::Project.new(OS::Path.get_basename(path))
		@curr_project.name = doc.root["Name"]
		@curr_project_path = project_path if project_path != nil
		@curr_project_path = OS::Path.normalise(OS::Path.get_directory(path)) unless project_path != nil
		
		#files		
		files_node = doc.find_first("Files")	
		import_proj_files(files_node,@curr_project)
		
		#root config
		configs_node = doc.find_first("Configurations")	
		import_root_configs(configs_node)
		
		@curr_project.guid = doc.root.attributes["ProjectGUID"]
		@curr_project.config.xml_data = XML::Node.new("config")
		
		@log.debug("parsed #{path}")
		
		return true, @curr_project
	end	
	
protected

	def strip_unused_info( doc )
	
		doc.find("/VisualStudioProject/Configurations/Configuration/Tool").each { |xml_node|
		
			case xml_node.attributes["Name"]
			
			when "VCWebDeploymentTool":
				
				xml_node.remove!
			end
		}
	end	
	
	def import_file_config_hierarchy( xml_in )
	
		xml_out = nil
	
		if xml_in.name == "FileConfiguration" then
		
			xml_out = XML::Node.new("config")
			clone_attributes(xml_in,xml_out)
		elsif xml_in.name == "Tool" then
				
			xml_out = XML::Node.new(xml_in.attributes["Name"])
			clone_attributes(xml_in,xml_out)
		elsif xml_in.name == "custombuild" then
		
			xml_out = XML::Node.new(xml_in.attributes["Name"])
			clone_attributes(xml_in,xml_out)
		end
		
#		if xml_out == nil then
#
#			ProjBuilder.log.debug("Not loaded!")
#			ProjBuilder.log.debug(xml_in)
#		end
				
		if xml_out != nil and xml_in.children? then
				
			xml_in.children.each { |child|						
						
				xml_new = import_file_config_hierarchy(child)		
				xml_out << xml_new if xml_new != nil
			}
		end
	
		xml_out	
	end
	
	def import_proj_files( xml_node, filter_node )
	
		xml_node.find("File").each do |xml_file_node|
								
			file_path = xml_file_node.attributes["RelativePath"]
			file_path = File.expand_path(file_path,@curr_project_path)
			
			new_file = Info::File.new(file_path)
			
			xml_file_node.find("FileConfiguration").each do |xml_file_config_node|
		
				platform, target = VSProjShared.parse_config_name(xml_file_config_node.attributes["Name"])			
				next if (platform == nil or target == nil)			
				config = new_file.platforms[platform].get_target(target)				
				config.xml_data = import_file_config_hierarchy(xml_file_config_node) 
			end

			filter_node.files << new_file
		end
		
		xml_node.find("Filter").each do |xml_filter_node|

			new_filter_node = Info::Filter.new(xml_filter_node.attributes["Name"])
			filter_node.filters << new_filter_node		
			
			import_proj_files(xml_filter_node,new_filter_node)
		end		
	end	
	
	def import_config_hierarchy( xml_in, doc, platform, target )
	
		xml_out = nil
	
		if xml_in.name == "Configuration" then
		
			doc.root = XML::Node.new("config")
			xml_out = XML::Node.new("vc")
			doc.root << xml_out
			
			case xml_in["ConfigurationType"]
			
			when "1": doc.root["type"] = :exe.to_s
			when "2": doc.root["type"] = :dll.to_s
			when "4": doc.root["type"] = :library.to_s
			
			end
			
			doc.root["output_path"] = xml_in["OutputDirectory"].downcase if xml_in["OutputDirectory"]

		elsif xml_in.name == "Tool" or xml_in.name == "custombuild"
		
			found = false
		
			if xml_in["Name"] == "VCCLCompilerTool" or xml_in["Name"] == "VCCLX360CompilerTool" then
			
				if xml_in["AdditionalIncludeDirectories"] then
				
					found = true
					xml_incpaths = create_xml_path(doc.root,"includepaths")
					dirs = xml_in["AdditionalIncludeDirectories"].split(";")
					xml_in.attributes.get_attribute("AdditionalIncludeDirectories").remove!
					
					dirs.each { |dir|
					
						xml_incpath = XML::Node.new("includepath")
						xml_incpath["path"] = dir
						
						xml_incpaths << xml_incpath
					}
				end
				
				if xml_in["PreprocessorDefinitions"] then
				
					found = true
					xml_defines = create_xml_path(doc.root,"defines")
					defines = xml_in["PreprocessorDefinitions"].split(";")
					xml_in.attributes.get_attribute("PreprocessorDefinitions").remove!
					
					defines.each { |define|
					
						next if define == ""
					
						xml_define = XML::Node.new("define")
						xml_define["value"] = define
						
						xml_defines << xml_define
					}					
				end
				
				if xml_in["ForcedIncludeFiles"] then
				
					found = true
					xml_forceincludes = create_xml_path(doc.root,"forceincludes")
					forceincludes = xml_in["ForcedIncludeFiles"].split(";")
					xml_in.attributes.get_attribute("ForcedIncludeFiles").remove!
					
					i = 0
					
					forceincludes.each { |forceinclude|
					
						xml_forceinclude = XML::Node.new("forceinclude")
						xml_forceinclude["path"] = forceinclude
						xml_forceinclude["order"] = i.to_s
						
						i = i + 1
						
						xml_forceincludes << xml_forceinclude
					}	
				end
			end
		
			if (xml_in.attributes["Name"] != nil and xml_in.attributes.length > 1) then
		
				xml_out = XML::Node.new(xml_in.attributes["Name"])		
				clone_attributes(xml_in,xml_out)
			end
		elsif xml_in.name == "DebuggerTool" then
		
			xml_out = XML::Node.new("DebuggerTool")
			clone_attributes(xml_in,xml_out)			
		end
		
#		if xml_out == nil then
#
#			ProjBuilder.log.debug("Not loaded!")
#			ProjBuilder.log.debug(xml_in)
#		end
		
		if xml_out != nil and xml_in.children? then
		
			xml_in.children.each { |child|						
			
				xml_new = import_config_hierarchy(child,doc,platform,target)				
				xml_out << xml_new if xml_new != nil
			}
		end
	
		xml_out
	end
	
	def import_root_config( xml_node )

		platform, target = VSProjShared.parse_config_name(xml_node.attributes["Name"])	
		return nil if ( platform.nil? or target.nil? )
          
		config = @curr_project.platforms[platform].get_target(target)	
		
		doc = XML::Document.new()		
		import_config_hierarchy(xml_node,doc,platform,target)
		
		config.xml_data = doc.root
	end
	
	def import_root_configs( xml_node )
	
		config_nodes = xml_node.find("Configuration")	
		
		config_nodes.each do |xml_config_node|
			
			import_root_config(xml_config_node)
		end
	end	
end

class VS2008SlnLoader

	attr_reader :projects

	@@log = nil 

	def VS2008SlnLoader.log

		@@log = Log.new( 'vs2008slnloader' ) if @@log == nil
		@@log
	end

	def initialize()
	
		@log = VS2008SlnLoader.log
	end
	
	def import( path )
			
		@log.debug("parsing #{path}")
			
		#make sure the path is absolute...
		
		#set the parent path
		@sln_dir = OS::Path.normalise(OS::Path.get_directory(path))
			
		sln_lines = File.readlines(path)
	
		# puts(sln_lines[0]) #first line is just a file format comment
	
		state = :none
	
		line_buffer = Array.new()
	
		sln_lines.each { |line|
		
			case state
			when :none
			
				if line.index("Project") == 0 then
				
					state = :project
					line_buffer = Array.new()
					line_buffer << line
				end

				if line.index("Global") == 0 then
				
					state = :global
					line_buffer = Array.new()
					line_buffer << line
				end
				
			when :project
			
				if line.index("EndProject") == 0 then

					state = :none
					line_buffer << line
					load_sln_project_section(line_buffer)
				else
				
					line_buffer << line
				end

			when :global
			
				if line.index("EndGlobal") == 0 then

					state = :none
					line_buffer << line
					load_sln_global_section(line_buffer)
				else
				
					line_buffer << line
				end
			
			end			
		}
		
		return true, nil
	end
	
	def load_sln_project_section( lines )
			
		tokens = lines[0].split("=")
		tokens = tokens[1].split(",")
		
		name = tokens[0]
		proj_file = tokens[1].strip
		proj_file = OS::Path.normalise(proj_file[1...(proj_file.size - 1)])
		proj_file = File.expand_path(proj_file,@sln_dir)
		
		guid = tokens[2]
		deps = Array.new()
		
		state = :none
		
		lines.each { |line|
			
			case state
			
			when :none
			
				if line.strip.index("ProjectSection(ProjectDependencies) = postProject") == 0 then
				
					state = :deps
					
				end
			when :deps
			
				if line.strip.index("EndProjectSection") == 0 then
				
					state = :none
				else
				
					deps << line.split("=")[0].strip
				end
			end
		}
		
		loader = VS2008VSProjLoader.new()
		ret, project = loader.import(proj_file)
		
		ProjBuildData::instance().projects[project.guid] = project if ret == true
	end	
	
	def load_sln_global_section( lines )
	
		state = :none
		
		lines.each { |line|
			
			case state
			
			when :none
			
				if line.strip.index("GlobalSection(ProjectConfigurationPlatforms) = postSolution") == 0 then
				
					state = :configs
					
				end
			when :configs
			
				if line.strip.index("EndGlobalSection") == 0 then
				
					state = :none
				else
										
					tokens = line.strip.split("=")
					
					prj_data = tokens[0]
					sln_cfg = tokens[1].strip
					
					tokens = prj_data.split(".")
					
					guid = tokens[0].strip
					prj_cfg = tokens[1].strip
					command = tokens[2].strip
					
					if command == "ActiveCfg" then
						
						sln_tokens = sln_cfg.split("|")						
						sln_platform = sln_tokens[1]
						sln_target = sln_tokens[0]
						
						proj_platform, proj_target = VSProjShared.parse_config_name(prj_cfg)
						
						ProjBuildData::instance().add_projectconfig(sln_platform,sln_target,guid,proj_platform,proj_target)
					end				
				end
			end
		}	
	end
end

class VS2008Generator
	
	@@log = nil 	

	def VS2008Generator.log

		@@log = Log.new( 'VS2008Generator' ) if @@log == nil
		@@log
	end

	def initialize()
	
		@log = VS2008Generator.log		
	end	

	GENERATOR_ID = "2008"
	
	@@unity_build_filenames	= nil # if true filenames that are created have "_unity" in them.
	def set_unity_build_filenames( set )
		@@unity_build_filenames = set
	end

	def get_unity_build_filenames( )
		@@unity_build_filenames
	end	
	
	def self.get_project_filename( basename )	
		(@@unity_build_filenames and not basename.downcase.include?("shaders")) ? "#{basename}_#{GENERATOR_ID}_unity.vcproj" 	: "#{basename}_#{GENERATOR_ID}.vcproj"
	end

	def self.get_solution_filename( basename )		
		(@@unity_build_filenames and not basename.downcase.include?("shaders")) ? "#{basename}_#{GENERATOR_ID}_unity.sln" : "#{basename}_#{GENERATOR_ID}.sln"		
	end	
	
	def export( path, project, options = nil )

		VS2008Generator.log.debug("exporting #{path} through vs2008 path")
	
		if options != nil and options[:type] == :solution then
		
			return VS2008VSSlnExporter.new().export(path,project)
		else		
			path = VS2008Generator.get_project_filename(path)
			return VS2008VSProjExporter.new().export(path,project)
		end
			
		false
	end
	
	def import( path, options = nil )
	
		case OS::Path::get_extension(path).downcase
		
		when 'sln': 
		
			@log.debug("import solution #{path}")
		
			loader = VS2008SlnLoader.new()
			return loader.import(path)
			
		when 'vcproj':
			
			@log.debug("import project #{path}")
			
			loader = VS2008VSProjLoader.new()
			return loader.import(path)
		end
		
		false
	end
end

end #module ProjBuild

end #module Pipeline