EmuXPortal/Api/RomParser.cs

//#define LIST_ADDED_ROMS // when defined will log all found rom files
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EmuXPortal.Logging;
using System.IO;
using System.Diagnostics;

namespace EmuXPortal.Api
{
    public class RomParser :IDisposable
    {
        private IEmuConfig Config { get; set; }
        public RomParser(logger log, IEmuConfig config)
        {
            this.Config = config;
            if (!this.Config.IsFavorites)
            {
                List<IRomConfigPair> roms = GetRoms(log);
                log.WriteLine("Found {0} Roms", roms.Count);
                this.Roms = GenerateRomConfig(log, roms, config);
            }
            else
            {
                this.Roms = RomFavorite.GetRoms(log);
                log.WriteLine("Found {0} Roms", this.Roms.Count);
            }
        }
        public List<IRomConfig> Roms { get; private set; }
        private List<IRomConfigPair> GetRoms(logger log)
        {
            if (Config.HasExternalConfigs) { return GetRomsEX(log); }
            string path = Config.EmuRomPath; string searchPattern = Config.Extenstions;
            log.WriteLine("Searching for Roms in Folder: {0}", path);
            Predicate<string> rom_predicate = new Predicate<string>(delegate(string t)
                {
                    string search_exts = searchPattern.Replace("*", "");
                    List<string> exts = new List<string>(search_exts.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries));             
                    string ext = Path.GetExtension(t).ToLower();
                    return exts.Contains(ext) && t.ToLower().EndsWith(ext);
                });
               List<string> roms = (searchPattern == "*.*")
                   ? new List<string>(Directory.GetFiles(path, "*.*", SearchOption.AllDirectories))
                   : new List<string>(Directory.GetFiles(path, "*.*", SearchOption.AllDirectories).Where(s => rom_predicate(s)));
            
            #region LIST_ADDED_ROMS
#if LIST_ADDED_ROMS
            foreach (string rom in roms)
            {
                FileInfo fi = new FileInfo(rom);
                logger.WriteLine("\tAdding: {0}", fi.Name);
            }
#endif
            List<IRomConfigPair> rompairlist = new List<IRomConfigPair>();
            foreach (string rom in roms)
            {
                rompairlist.Add(new RomConfigPair(rom, Config));
            }
            #endregion
            return rompairlist;
        }

        private List<IRomConfigPair> GetRomsEX(logger log)
        {
            List<IEmuConfig> configs = Config.ExternalConfigs;
            List<IRomConfigPair> roms = new List<IRomConfigPair>();


            foreach (IEmuConfig config in configs)
            {
                var reconfig = FixExternalConfig(log,Config, config);
               roms.Add(new RomConfigPair(reconfig.GameExe, reconfig));
            }

            return roms;
        }
        private IEmuConfig FixExternalConfig(logger log,IEmuConfig parent_config, IEmuConfig child_config)
        {
            string PlatformNameShort = child_config.PlatformNameShort.Contains("Unknown") ? parent_config.PlatformNameShort != "" ? parent_config.PlatformNameShort : "" : child_config.PlatformNameShort;
            string PlatformNameLong = child_config.PlatformNameLong.Contains("Unknown") ? parent_config.PlatformNameLong != "" ? parent_config.PlatformNameLong : "" : child_config.PlatformNameLong;
            string PlatformImage = child_config.GameImage == "" ? parent_config.GameImage != "" ? parent_config.GameImage : "" : child_config.GameImage;
            string Extenstions = child_config.Extenstions == "" ? parent_config.Extenstions != "" ? parent_config.Extenstions : "" : child_config.Extenstions;
            string EmuPath = child_config.EmuPath == "" ? parent_config.EmuPath != "" ? parent_config.EmuPath : "" : child_config.EmuPath;
            string EmuOptions = child_config.EmuOptions == "" ? parent_config.EmuOptions != "" ? parent_config.EmuOptions : "" : child_config.EmuOptions;

            FileInfo fi = new FileInfo(PlatformImage);
            if (!fi.Exists)
            {
                PlatformImage = string.Format(@"{0}\{1}", new FileInfo(child_config.GameExe).Directory.FullName, PlatformImage);
                fi = new FileInfo(PlatformImage);
                if (!fi.Exists)
                {
                    PlatformImage = string.Format(@"{0}\{1}", new FileInfo(parent_config.EmuRomPath).Directory.FullName, PlatformImage);
                    fi = new FileInfo(PlatformImage);
                    if (!fi.Exists) { PlatformImage = ""; }
                }
            }
            fi = null;

            EmuXPortal.Api.EmuConfigLoader.EmuConfig c = new EmuConfigLoader.EmuConfig(log, 
                PlatformNameShort, PlatformNameLong, PlatformImage,
                Extenstions, EmuPath, EmuOptions);
            c.EmuRomPath = string.IsNullOrEmpty(child_config.EmuRomPath) ? string.IsNullOrEmpty(parent_config.EmuRomPath) ? "" : parent_config.EmuRomPath : child_config.EmuRomPath;

                        
            c.GameExe = child_config.GameExe;
            c.GameExeArgs = child_config.GameExeArgs;
            c.GameImage = child_config.GameImage;
            c.GameTitle = child_config.GameTitle;
            c.ConfigPath = child_config.ConfigPath;
            return c;
        }
        private List<IRomConfig> GenerateRomConfig(logger log, List<IRomConfigPair> roms, IEmuConfig config)
        {
            List<IRomConfig> romconfigs = new List<IRomConfig>();
            log.WriteLine("Generating Rom Configs");
            foreach (IRomConfigPair rom in roms) { romconfigs.Add(RomLoader.Load(log, rom.RomFile, rom.RomConfig)); }
            return romconfigs;
        }

        private interface IRomConfigPair
        {
            string RomFile { get; }
            IEmuConfig RomConfig { get; }
        }
        private class RomConfigPair : IRomConfigPair
        {
            public RomConfigPair() : this("", EmuConfigLoader.Empty) { }
            public RomConfigPair(string romFile, IEmuConfig romConfig) { RomFile = romFile; RomConfig = romConfig; }
            #region IRomConfigPair members
            public string RomFile { get; private set; }
            public IEmuConfig RomConfig { get; private set; }
            #endregion
        }

        public void Dispose()
        {
            Roms.ForEach(x => x.Dispose());
            Roms.Clear();
            Roms = null;
        }
    }
}
1	william	38	//#define LIST_ADDED_ROMS // when defined will log all found rom files
2			using System;
3	william	18	using System.Collections.Generic;
4			using System.Linq;
5			using System.Text;
6			using EmuXPortal.Logging;
7			using System.IO;
8	william	38	using System.Diagnostics;
9	william	18
10			namespace EmuXPortal.Api
11			{
12	william	105	public class RomParser :IDisposable
13	william	18	{
14	william	85	private IEmuConfig Config { get; set; }
15	william	112	public RomParser(logger log, IEmuConfig config)
16	william	18	{
17	william	85	this.Config = config;
18	william	175	if (!this.Config.IsFavorites)
19			{
20			List<IRomConfigPair> roms = GetRoms(log);
21			log.WriteLine("Found {0} Roms", roms.Count);
22			this.Roms = GenerateRomConfig(log, roms, config);
23			}
24			else
25			{
26			this.Roms = RomFavorite.GetRoms(log);
27			log.WriteLine("Found {0} Roms", this.Roms.Count);
28			}
29	william	18	}
30			public List<IRomConfig> Roms { get; private set; }
31	william	112	private List<IRomConfigPair> GetRoms(logger log)
32	william	18	{
33	william	199	if (Config.HasExternalConfigs) { return GetRomsEX(log); }
34	william	85	string path = Config.EmuRomPath; string searchPattern = Config.Extenstions;
35	william	112	log.WriteLine("Searching for Roms in Folder: {0}", path);
36	william	107	Predicate<string> rom_predicate = new Predicate<string>(delegate(string t)
37			{
38			string search_exts = searchPattern.Replace("*", "");
39			List<string> exts = new List<string>(search_exts.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries));
40			string ext = Path.GetExtension(t).ToLower();
41			return exts.Contains(ext) && t.ToLower().EndsWith(ext);
42			});
43			List<string> roms = (searchPattern == ".")
44			? new List<string>(Directory.GetFiles(path, ".", SearchOption.AllDirectories))
45			: new List<string>(Directory.GetFiles(path, ".", SearchOption.AllDirectories).Where(s => rom_predicate(s)));
46
47	william	38	#region LIST_ADDED_ROMS
48			#if LIST_ADDED_ROMS
49			foreach (string rom in roms)
50			{
51			FileInfo fi = new FileInfo(rom);
52			logger.WriteLine("\tAdding: {0}", fi.Name);
53			}
54			#endif
55	william	85	List<IRomConfigPair> rompairlist = new List<IRomConfigPair>();
56			foreach (string rom in roms)
57			{
58			rompairlist.Add(new RomConfigPair(rom, Config));
59			}
60	william	38	#endregion
61	william	85	return rompairlist;
62			}
63
64	william	199	private List<IRomConfigPair> GetRomsEX(logger log)
65	william	85	{
66			List<IEmuConfig> configs = Config.ExternalConfigs;
67			List<IRomConfigPair> roms = new List<IRomConfigPair>();
68
69
70	william	199	foreach (IEmuConfig config in configs)
71			{
72			var reconfig = FixExternalConfig(log,Config, config);
73			roms.Add(new RomConfigPair(reconfig.GameExe, reconfig));
74			}
75	william	85
76	william	18	return roms;
77			}
78	william	199	private IEmuConfig FixExternalConfig(logger log,IEmuConfig parent_config, IEmuConfig child_config)
79			{
80			string PlatformNameShort = child_config.PlatformNameShort.Contains("Unknown") ? parent_config.PlatformNameShort != "" ? parent_config.PlatformNameShort : "" : child_config.PlatformNameShort;
81			string PlatformNameLong = child_config.PlatformNameLong.Contains("Unknown") ? parent_config.PlatformNameLong != "" ? parent_config.PlatformNameLong : "" : child_config.PlatformNameLong;
82			string PlatformImage = child_config.GameImage == "" ? parent_config.GameImage != "" ? parent_config.GameImage : "" : child_config.GameImage;
83			string Extenstions = child_config.Extenstions == "" ? parent_config.Extenstions != "" ? parent_config.Extenstions : "" : child_config.Extenstions;
84			string EmuPath = child_config.EmuPath == "" ? parent_config.EmuPath != "" ? parent_config.EmuPath : "" : child_config.EmuPath;
85			string EmuOptions = child_config.EmuOptions == "" ? parent_config.EmuOptions != "" ? parent_config.EmuOptions : "" : child_config.EmuOptions;
86	william	85
87	william	199	FileInfo fi = new FileInfo(PlatformImage);
88			if (!fi.Exists)
89			{
90			PlatformImage = string.Format(@"{0}\{1}", new FileInfo(child_config.GameExe).Directory.FullName, PlatformImage);
91			fi = new FileInfo(PlatformImage);
92			if (!fi.Exists)
93			{
94			PlatformImage = string.Format(@"{0}\{1}", new FileInfo(parent_config.EmuRomPath).Directory.FullName, PlatformImage);
95			fi = new FileInfo(PlatformImage);
96			if (!fi.Exists) { PlatformImage = ""; }
97			}
98			}
99			fi = null;
100
101			EmuXPortal.Api.EmuConfigLoader.EmuConfig c = new EmuConfigLoader.EmuConfig(log,
102			PlatformNameShort, PlatformNameLong, PlatformImage,
103			Extenstions, EmuPath, EmuOptions);
104			c.EmuRomPath = string.IsNullOrEmpty(child_config.EmuRomPath) ? string.IsNullOrEmpty(parent_config.EmuRomPath) ? "" : parent_config.EmuRomPath : child_config.EmuRomPath;
105
106
107			c.GameExe = child_config.GameExe;
108			c.GameExeArgs = child_config.GameExeArgs;
109			c.GameImage = child_config.GameImage;
110			c.GameTitle = child_config.GameTitle;
111			c.ConfigPath = child_config.ConfigPath;
112			return c;
113			}
114	william	112	private List<IRomConfig> GenerateRomConfig(logger log, List<IRomConfigPair> roms, IEmuConfig config)
115	william	18	{
116			List<IRomConfig> romconfigs = new List<IRomConfig>();
117	william	112	log.WriteLine("Generating Rom Configs");
118			foreach (IRomConfigPair rom in roms) { romconfigs.Add(RomLoader.Load(log, rom.RomFile, rom.RomConfig)); }
119	william	18	return romconfigs;
120			}
121	william	85
122			private interface IRomConfigPair
123			{
124			string RomFile { get; }
125			IEmuConfig RomConfig { get; }
126			}
127			private class RomConfigPair : IRomConfigPair
128			{
129			public RomConfigPair() : this("", EmuConfigLoader.Empty) { }
130			public RomConfigPair(string romFile, IEmuConfig romConfig) { RomFile = romFile; RomConfig = romConfig; }
131			#region IRomConfigPair members
132			public string RomFile { get; private set; }
133			public IEmuConfig RomConfig { get; private set; }
134			#endregion
135			}
136	william	105
137			public void Dispose()
138			{
139			Roms.ForEach(x => x.Dispose());
140			Roms.Clear();
141			Roms = null;
142			}
143	william	18	}
144	william	199	}