trunk/GBPVRProgramDatabaseFixer/Program.cs

#define OVERRIDE_COMMANDLINE_ARGUMENTS // when defined will override supplied commandline args
using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using Enterprise.Logging;
using System.Windows.Forms;
using System.Diagnostics;
using System.IO;
using libxmltv.Core;
using libxmltv.Interfaces;
using libxmltv;
namespace GBPVRProgramDatabaseFixer
{
    class Program
    {
        static ISQLLITE sqlite;
        static string XMLTV_FILE = "";
        static string GBPVR_DATABASE = "";

        //static bool LOADING_XMLTV_FILE = false;
        static bool XMLTV_INSTANCE_CREATED = false;
        //static int LAST_REPORTED_XMLTV_PROGRESS = 0;


        //static bool LOADING_GBPVR_DATABASE = false;
        static bool SQLLIST_INSTANCE_CREATED = false;
        //static int LAST_REPORTED_SQLLITE_PROGRESS = 0;

        static int LAST_REPORTED_PROGRESS = 0;

        static FileInfo fi_XMLTVFILE;
        static FileInfo fi_GBPVRDATABASE;
        static void CreateLog()
        {
            string log_path = Application.StartupPath;
            string log_filename = string.Format("{0}.log", typeof(Program).Assembly.GetName().Name);
            gLog.CreateLog(string.Format(@"{0}\{1}", log_path, log_filename), false, LogLevel.kLogLevel_All);
#if DEBUG
            LogLevel gLevel = gLog.LogLevel;
            gLevel |= LogLevel.kLogLevel_VerboseDebug;
            gLevel |= LogLevel.kLogLevel_Debug;
            gLog.SetLogLevel(gLevel);
#else
            LogLevel gLevel = LogLevel.kLogLevel_Default; // set the default log level: Info, Warn, Error, Debug
            // it is OK for kLogLevel_Debug to be set in Release mode ... must of the chatty messages are from kLogLevel_VerboseDebug
            gLevel &= ~LogLevel.kLogLevel_Debug; // ensure this is not set, ever in release mode         
            gLevel &= ~LogLevel.kLogLevel_VerboseDebug; // ensure this is not set, ever in release mode         
            gLog.SetLogLevel(gLevel);
#endif
            gLog.ReportProgressEvent += new EventHandler<ReportProgressEventArgs>(gLog_ReportProgress);
        }

        [Conditional("OVERRIDE_COMMANDLINE_ARGUMENTS")]
        static void CreateDebugCommandlineArgs(ref List<string> cargs)
        {
           cargs = new List<string>();
            cargs.Add(string.Format("--xmltv_file=\"{0}\"", @"c:\EPG Guide\Guide\tvguide.xml"));
            cargs.Add(string.Format("--gbprv_db=\"{0}\"", @"c:\Program Files (x86)\Devnz\GBPVR\gbpvr.db3"));
        }

        static List<string> CreateCommandlineArgs(string[] args)
        {
            List<string> cargs = new List<string>(args);
            CreateDebugCommandlineArgs(ref cargs);
            return cargs;
        }

        static void Main(string[] args)
        {
            CreateLog();
            var cargs = CreateCommandlineArgs(args);
            foreach (var carg in cargs)
            {
                if (carg.ToLower().Contains("--xmltv_file="))
                {
                    XMLTV_FILE = carg.Replace("--xmltv_file=", "").Replace("\"","");
                    gLog.Info.WriteLine("XMLTV FILE: '{0}'", XMLTV_FILE);
                }
                else if (carg.ToLower().Contains("--gbprv_db="))
                {
                    GBPVR_DATABASE = carg.Replace("--gbprv_db=", "").Replace("\"", "");
                    gLog.Info.WriteLine("GBPVR DATABASE: '{0}'", GBPVR_DATABASE);
                }
                else
                {
                    gLog.Warn.WriteLine("Unknown commandline option: {0}", carg);
                }
            }

            LoadXMLTVFile();
            LoadGBPVRDatabase();
            PerformDatabaseProcessing();
        }

        static void ConsoleOverwritePreviosLine(string format, params object[] args)
        {
            Console.WriteLine(format,args);
            Console.SetCursorPosition(0, Console.CursorTop - 1);
        }

        static void gLog_ReportProgress(object sender, ReportProgressEventArgs e) 
        {
            //if (!XMLTV_INSTANCE_CREATED && LOADING_XMLTV_FILE)
            //{
            //    if (LAST_REPORTED_XMLTV_PROGRESS != e.Progress)
            //    {
            //        ConsoleOverwritePreviosLine("XMLTV: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
            //        LAST_REPORTED_XMLTV_PROGRESS = e.Progress;
            //        if (e.Progress == 100)
            //        {
            //            Console.WriteLine("XMLTV: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
            //        }
            //    }
            //}
            //if (!SQLLIST_INSTANCE_CREATED && LOADING_GBPVR_DATABASE)
            //{
            //    if (LAST_REPORTED_SQLLITE_PROGRESS != e.Progress)
            //    {
            //        ConsoleOverwritePreviosLine("SQLLITE: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
            //        LAST_REPORTED_SQLLITE_PROGRESS = e.Progress;
            //        if (e.Progress == 100)
            //        {
            //            Console.WriteLine("SQLLITE: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
            //        }
            //    }
            //}

            object k = e.UserState;
            if (k == null)
            {
                if (sender == null)
                {
                    if (LAST_REPORTED_PROGRESS != e.Progress)
                    {
                        ConsoleOverwritePreviosLine("Progress: {0} ", e.Progress);
                        LAST_REPORTED_PROGRESS = e.Progress;
                        if (e.Progress == 100)
                        {
                            Console.WriteLine("Progress: {0} ", e.Progress);
                        }
                    }
                }
                else
                {
                    if (LAST_REPORTED_PROGRESS != e.Progress)
                    {
                        ConsoleOverwritePreviosLine("{0}: Progress: {1:00}%", sender.GetType().Name, e.Progress);
                        LAST_REPORTED_PROGRESS = e.Progress;
                        if (e.Progress == 100)
                        {
                            Console.WriteLine("{0}: Progress: {1:00}%", sender.GetType().Name, e.Progress);
                        }
                    }
                }
            }
            else
            {
                if (sender == null)
                {
                    if (LAST_REPORTED_PROGRESS != e.Progress)
                    {
                        ConsoleOverwritePreviosLine("Progress: {0} ", k.ToString());
                        LAST_REPORTED_PROGRESS = e.Progress;
                        if (e.Progress == 100)
                        {
                            Console.WriteLine("Progress: {0} ", k.ToString());
                        }
                    }
                }
                else
                {
                    if (LAST_REPORTED_PROGRESS != e.Progress)
                    {
                        ConsoleOverwritePreviosLine("{0}: {1}", sender.GetType().Name, k.ToString());
                        LAST_REPORTED_PROGRESS = e.Progress;
                        if (e.Progress == 100)
                        {
                            Console.WriteLine("{0}: {1}", sender.GetType().Name, k.ToString());
                        }
                    }
                }
            }
        }
        static void LoadXMLTVFile()
        {
            //LOADING_XMLTV_FILE = true;
            if (string.IsNullOrEmpty(XMLTV_FILE))
            {
                gLog.Error.WriteLine("XMLTV File is either a null or empty string.");
                //LOADING_XMLTV_FILE = false;
                return;
            }
            fi_XMLTVFILE = new FileInfo(XMLTV_FILE);
            if (!fi_XMLTVFILE.Exists)
            {
                gLog.Error.WriteLine("Could not find XMLTV File: {0}", fi_XMLTVFILE.FullName);
                //LOADING_XMLTV_FILE = false;
                return;
            }

            XMLTV.Create(fi_XMLTVFILE.FullName, new EventHandler<EventArgs>(XMLTV_OnInstanceCreated));
            while (!XMLTV_INSTANCE_CREATED) { Application.DoEvents(); }
            //LOADING_XMLTV_FILE = false;
        }
        static void XMLTV_OnInstanceCreated(object sender, EventArgs e) { XMLTV_INSTANCE_CREATED = true; }

        static void LoadGBPVRDatabase()
        {
            //LOADING_GBPVR_DATABASE = true;
            if (string.IsNullOrEmpty(GBPVR_DATABASE))
            {
                gLog.Error.WriteLine("GBPVR Datbase is either a null or empty string.");
                //LOADING_GBPVR_DATABASE = false;
                return;
            }
            fi_GBPVRDATABASE = new FileInfo(GBPVR_DATABASE);
            if (!fi_GBPVRDATABASE.Exists)
            {
                gLog.Error.WriteLine("Could not find GBPVR Database: {0}", fi_GBPVRDATABASE.FullName);
                //LOADING_GBPVR_DATABASE = false;
                return;
            }
            sqlite = SQLLITE.Create(fi_GBPVRDATABASE.FullName, new EventHandler<EventArgs>(SQLLITE_OnInstanceCreated));
            while (!SQLLIST_INSTANCE_CREATED) { Application.DoEvents(); }
            //LOADING_GBPVR_DATABASE = false;
        }
        static void SQLLITE_OnInstanceCreated(object sender, EventArgs e) { SQLLIST_INSTANCE_CREATED = true; }


        //static List<SQLLITE.IPROGRAMME> gbpvr_invalid_programs;
        //static List<SQLLITE.IPROGRAMME> gbpvr_valid_programs;
        //static List<SQLLITE.ICHANNEL> gbpvr_channels;
        //static List<SQLLITE.IRECORDING_SCHEDULE> gbpvr_recordings;
        //static List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs;
        static void PerformDatabaseProcessing()
        {
            var sqllite_channels = sqlite.Channels;
            var sqllite_recordings = sqlite.Recordings;
            var sqllite_programs = sqlite.Programs;
            Type datatype;
            var xmlt_raw_program_data = (IProgramDefinitionList)XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out datatype);
            var xmltv_programs = xmlt_raw_program_data.ToList().OrderBy(p => DateTime.Parse(p.Start)).ToList();
            var sqllite_programs_startdate_range = sqlite.GetProgramsDateRange(sqllite_programs);
            var xmltv_programs_startdate_range = GetXMLTVProgramStartDateRange(xmltv_programs);
            var gbpvr_invalid_programs = new List<SQLLITE.IPROGRAMME>();
            var gbpvr_valid_programs = sqlite.GetValidPrograms(sqllite_programs, xmltv_programs, out gbpvr_invalid_programs);
            xmltv_programs = xmltv_programs.OrderBy(s => s.ChannelNumber).ThenBy(s => DateTime.Parse(s.Start)).ToList();
            //sqllite_channels.TrimExcess();
            //gbpvr_invalid_programs.TrimExcess();
            //gbpvr_valid_programs.TrimExcess();
            //sqllite_programs.TrimExcess();
            //xmltv_programs.TrimExcess();
            //CheckScheduledRecordingsForDiscrepancies(sqllite_recordings);
            //CheckProgramsForDiscrepancies(gbpvr_valid_programs, xmltv_programs);
        }

        static IDateTimeRange GetXMLTVProgramStartDateRange(List<libxmltv.Interfaces.IProgramDefinition> programs)
        {
            IDateTimeRange range = DateTimeRange.Create();
            var list = new List<libxmltv.Interfaces.IProgramDefinition>(programs.ToArray());
            DateTime first = new DateTime();
            DateTime last = new DateTime();
            first = DateTime.Parse(list.OrderBy(s => DateTime.Parse(s.Start)).ToList().First().Start);
            last = DateTime.Parse(list.OrderBy(s => DateTime.Parse(s.Start)).ToList().Last().Start);
            gLog.Info.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());
            gLog.Info.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());
            range = DateTimeRange.Create(first, last);
            return range;
        }

        static void CheckScheduledRecordingsForDiscrepancies(List<SQLLITE.IRECORDING_SCHEDULE> gbpvr)
        {
            ////gLog.Warn.WriteLine("CheckScheduledRecordingsForDiscrepancies() has not been implemented");
            //var manual_gbpvr_recordings = gbpvr.FindAll(p => p.recording_type == 0).ToList();

            //foreach (var manual_recording in manual_gbpvr_recordings)
            //{
            //    string title = manual_recording.filename;
            //    DateTime start = manual_recording.manual_start_time;
            //    DateTime end = manual_recording.manual_end_time;
            //    long channel_oid = manual_recording.manual_channel_oid;
            //    var found_channel = gbpvr_channels.Find(p => p.oid == channel_oid);
            //    var channel_number = found_channel.channel_number;
            //    var found_program = xmltv_programs.ToList().Find(p => 
            //        p.Title.ToLower() == title.ToLower() && 
            //        p.Start == start.ToDateTimeString() &&
            //        p.Stop == end.ToDateTimeString() &&
            //        p.ChannelNumber == channel_number
            //        );
            //    if (found_program != null)
            //    {
            //        gLog.Info.WriteLine("Recording might be valid: oid='{0}' programme_oid='{1}' title='{2}' start='{3}', end='{4}'", manual_recording.oid, manual_recording.programme_oid, title, start.ToDateTimeString(), end.ToDateTimeString());
            //    }
            //    else
            //    {
            //        gLog.Warn.WriteLine("Recording may not be valid: oid='{0}' programme_oid='{1}' title='{2}' start='{3}', end='{4}'", manual_recording.oid, manual_recording.programme_oid, title, start.ToDateTimeString(), end.ToDateTimeString());
            //        // find the program on the channel at the start time
            //        var correct_program = xmltv_programs.ToList().Find(p => 
            //            p.ChannelNumber == channel_number &&
            //            p.Start == start.ToDateTimeString()
            //            );
            //        if (correct_program != null)
            //        {
            //            gLog.Warn.WriteLine("\tThis will be recorded: {0}", correct_program.ToString());
            //        }
            //    }
            //}
        }

        static void CheckProgramsForDiscrepancies(List<SQLLITE.IPROGRAMME> list_gbpvr, List<libxmltv.Interfaces.IProgramDefinition> list_xmltv)
        {
            ////gLog.Warn.WriteLine("CheckProgramsForDiscrepancies() has not been implemented");
            //var gbpvr = list_gbpvr.ToArray();
            //var xmltv = list_xmltv.ToArray();
            ////if (gbpvr.Count() != xmltv.Count())
            ////{
            ////    throw new ArgumentOutOfRangeException("gbpvr.Count/xmltv.Count", string.Format("gbpvr.Count: '0x{0:x8}' != xmltv.Count: '0x{1:x8}'", gbpvr.Count(),xmltv.Count()));
            ////}
            ////for (int i = 0; i < gbpvr.Count(); i++)
            ////{
            ////    var gbpvr_entry = gbpvr[i];
            ////    var xmltv_entry = gbpvr_entry.AsXMLTVProgramDefinition(sqlite);
            ////    if (!xmltv[i].Equals(xmltv_entry))
            ////    {
            ////        gLog.Warn.WriteLine("Warning GBPVR Program oid: {0} might be invalid", gbpvr_entry.oid);
            ////    }
            ////}
        }
    }
}
1	#define OVERRIDE_COMMANDLINE_ARGUMENTS // when defined will override supplied commandline args
2	using System;
3	using System.Collections.Generic;
4	using System.Text;
5	using System.Linq;
6	using Enterprise.Logging;
7	using System.Windows.Forms;
8	using System.Diagnostics;
9	using System.IO;
10	using libxmltv.Core;
11	using libxmltv.Interfaces;
12	using libxmltv;
13	namespace GBPVRProgramDatabaseFixer
14	{
15	class Program
16	{
17	static ISQLLITE sqlite;
18	static string XMLTV_FILE = "";
19	static string GBPVR_DATABASE = "";
20
21	//static bool LOADING_XMLTV_FILE = false;
22	static bool XMLTV_INSTANCE_CREATED = false;
23	//static int LAST_REPORTED_XMLTV_PROGRESS = 0;
24
25
26	//static bool LOADING_GBPVR_DATABASE = false;
27	static bool SQLLIST_INSTANCE_CREATED = false;
28	//static int LAST_REPORTED_SQLLITE_PROGRESS = 0;
29
30	static int LAST_REPORTED_PROGRESS = 0;
31
32	static FileInfo fi_XMLTVFILE;
33	static FileInfo fi_GBPVRDATABASE;
34	static void CreateLog()
35	{
36	string log_path = Application.StartupPath;
37	string log_filename = string.Format("{0}.log", typeof(Program).Assembly.GetName().Name);
38	gLog.CreateLog(string.Format(@"{0}\{1}", log_path, log_filename), false, LogLevel.kLogLevel_All);
39	#if DEBUG
40	LogLevel gLevel = gLog.LogLevel;
41	gLevel \|= LogLevel.kLogLevel_VerboseDebug;
42	gLevel \|= LogLevel.kLogLevel_Debug;
43	gLog.SetLogLevel(gLevel);
44	#else
45	LogLevel gLevel = LogLevel.kLogLevel_Default; // set the default log level: Info, Warn, Error, Debug
46	// it is OK for kLogLevel_Debug to be set in Release mode ... must of the chatty messages are from kLogLevel_VerboseDebug
47	gLevel &= ~LogLevel.kLogLevel_Debug; // ensure this is not set, ever in release mode
48	gLevel &= ~LogLevel.kLogLevel_VerboseDebug; // ensure this is not set, ever in release mode
49	gLog.SetLogLevel(gLevel);
50	#endif
51	gLog.ReportProgressEvent += new EventHandler<ReportProgressEventArgs>(gLog_ReportProgress);
52	}
53
54	[Conditional("OVERRIDE_COMMANDLINE_ARGUMENTS")]
55	static void CreateDebugCommandlineArgs(ref List<string> cargs)
56	{
57	cargs = new List<string>();
58	cargs.Add(string.Format("--xmltv_file=\"{0}\"", @"c:\EPG Guide\Guide\tvguide.xml"));
59	cargs.Add(string.Format("--gbprv_db=\"{0}\"", @"c:\Program Files (x86)\Devnz\GBPVR\gbpvr.db3"));
60	}
61
62	static List<string> CreateCommandlineArgs(string[] args)
63	{
64	List<string> cargs = new List<string>(args);
65	CreateDebugCommandlineArgs(ref cargs);
66	return cargs;
67	}
68
69	static void Main(string[] args)
70	{
71	CreateLog();
72	var cargs = CreateCommandlineArgs(args);
73	foreach (var carg in cargs)
74	{
75	if (carg.ToLower().Contains("--xmltv_file="))
76	{
77	XMLTV_FILE = carg.Replace("--xmltv_file=", "").Replace("\"","");
78	gLog.Info.WriteLine("XMLTV FILE: '{0}'", XMLTV_FILE);
79	}
80	else if (carg.ToLower().Contains("--gbprv_db="))
81	{
82	GBPVR_DATABASE = carg.Replace("--gbprv_db=", "").Replace("\"", "");
83	gLog.Info.WriteLine("GBPVR DATABASE: '{0}'", GBPVR_DATABASE);
84	}
85	else
86	{
87	gLog.Warn.WriteLine("Unknown commandline option: {0}", carg);
88	}
89	}
90
91	LoadXMLTVFile();
92	LoadGBPVRDatabase();
93	PerformDatabaseProcessing();
94	}
95
96	static void ConsoleOverwritePreviosLine(string format, params object[] args)
97	{
98	Console.WriteLine(format,args);
99	Console.SetCursorPosition(0, Console.CursorTop - 1);
100	}
101
102	static void gLog_ReportProgress(object sender, ReportProgressEventArgs e)
103	{
104	//if (!XMLTV_INSTANCE_CREATED && LOADING_XMLTV_FILE)
105	//{
106	// if (LAST_REPORTED_XMLTV_PROGRESS != e.Progress)
107	// {
108	// ConsoleOverwritePreviosLine("XMLTV: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
109	// LAST_REPORTED_XMLTV_PROGRESS = e.Progress;
110	// if (e.Progress == 100)
111	// {
112	// Console.WriteLine("XMLTV: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
113	// }
114	// }
115	//}
116	//if (!SQLLIST_INSTANCE_CREATED && LOADING_GBPVR_DATABASE)
117	//{
118	// if (LAST_REPORTED_SQLLITE_PROGRESS != e.Progress)
119	// {
120	// ConsoleOverwritePreviosLine("SQLLITE: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
121	// LAST_REPORTED_SQLLITE_PROGRESS = e.Progress;
122	// if (e.Progress == 100)
123	// {
124	// Console.WriteLine("SQLLITE: {0} Loading: {1:00}%", fi_XMLTVFILE.Name, e.Progress);
125	// }
126	// }
127	//}
128
129	object k = e.UserState;
130	if (k == null)
131	{
132	if (sender == null)
133	{
134	if (LAST_REPORTED_PROGRESS != e.Progress)
135	{
136	ConsoleOverwritePreviosLine("Progress: {0} ", e.Progress);
137	LAST_REPORTED_PROGRESS = e.Progress;
138	if (e.Progress == 100)
139	{
140	Console.WriteLine("Progress: {0} ", e.Progress);
141	}
142	}
143	}
144	else
145	{
146	if (LAST_REPORTED_PROGRESS != e.Progress)
147	{
148	ConsoleOverwritePreviosLine("{0}: Progress: {1:00}%", sender.GetType().Name, e.Progress);
149	LAST_REPORTED_PROGRESS = e.Progress;
150	if (e.Progress == 100)
151	{
152	Console.WriteLine("{0}: Progress: {1:00}%", sender.GetType().Name, e.Progress);
153	}
154	}
155	}
156	}
157	else
158	{
159	if (sender == null)
160	{
161	if (LAST_REPORTED_PROGRESS != e.Progress)
162	{
163	ConsoleOverwritePreviosLine("Progress: {0} ", k.ToString());
164	LAST_REPORTED_PROGRESS = e.Progress;
165	if (e.Progress == 100)
166	{
167	Console.WriteLine("Progress: {0} ", k.ToString());
168	}
169	}
170	}
171	else
172	{
173	if (LAST_REPORTED_PROGRESS != e.Progress)
174	{
175	ConsoleOverwritePreviosLine("{0}: {1}", sender.GetType().Name, k.ToString());
176	LAST_REPORTED_PROGRESS = e.Progress;
177	if (e.Progress == 100)
178	{
179	Console.WriteLine("{0}: {1}", sender.GetType().Name, k.ToString());
180	}
181	}
182	}
183	}
184	}
185	static void LoadXMLTVFile()
186	{
187	//LOADING_XMLTV_FILE = true;
188	if (string.IsNullOrEmpty(XMLTV_FILE))
189	{
190	gLog.Error.WriteLine("XMLTV File is either a null or empty string.");
191	//LOADING_XMLTV_FILE = false;
192	return;
193	}
194	fi_XMLTVFILE = new FileInfo(XMLTV_FILE);
195	if (!fi_XMLTVFILE.Exists)
196	{
197	gLog.Error.WriteLine("Could not find XMLTV File: {0}", fi_XMLTVFILE.FullName);
198	//LOADING_XMLTV_FILE = false;
199	return;
200	}
201
202	XMLTV.Create(fi_XMLTVFILE.FullName, new EventHandler<EventArgs>(XMLTV_OnInstanceCreated));
203	while (!XMLTV_INSTANCE_CREATED) { Application.DoEvents(); }
204	//LOADING_XMLTV_FILE = false;
205	}
206	static void XMLTV_OnInstanceCreated(object sender, EventArgs e) { XMLTV_INSTANCE_CREATED = true; }
207
208	static void LoadGBPVRDatabase()
209	{
210	//LOADING_GBPVR_DATABASE = true;
211	if (string.IsNullOrEmpty(GBPVR_DATABASE))
212	{
213	gLog.Error.WriteLine("GBPVR Datbase is either a null or empty string.");
214	//LOADING_GBPVR_DATABASE = false;
215	return;
216	}
217	fi_GBPVRDATABASE = new FileInfo(GBPVR_DATABASE);
218	if (!fi_GBPVRDATABASE.Exists)
219	{
220	gLog.Error.WriteLine("Could not find GBPVR Database: {0}", fi_GBPVRDATABASE.FullName);
221	//LOADING_GBPVR_DATABASE = false;
222	return;
223	}
224	sqlite = SQLLITE.Create(fi_GBPVRDATABASE.FullName, new EventHandler<EventArgs>(SQLLITE_OnInstanceCreated));
225	while (!SQLLIST_INSTANCE_CREATED) { Application.DoEvents(); }
226	//LOADING_GBPVR_DATABASE = false;
227	}
228	static void SQLLITE_OnInstanceCreated(object sender, EventArgs e) { SQLLIST_INSTANCE_CREATED = true; }
229
230
231	//static List<SQLLITE.IPROGRAMME> gbpvr_invalid_programs;
232	//static List<SQLLITE.IPROGRAMME> gbpvr_valid_programs;
233	//static List<SQLLITE.ICHANNEL> gbpvr_channels;
234	//static List<SQLLITE.IRECORDING_SCHEDULE> gbpvr_recordings;
235	//static List<libxmltv.Interfaces.IProgramDefinition> xmltv_programs;
236	static void PerformDatabaseProcessing()
237	{
238	var sqllite_channels = sqlite.Channels;
239	var sqllite_recordings = sqlite.Recordings;
240	var sqllite_programs = sqlite.Programs;
241	Type datatype;
242	var xmlt_raw_program_data = (IProgramDefinitionList)XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out datatype);
243	var xmltv_programs = xmlt_raw_program_data.ToList().OrderBy(p => DateTime.Parse(p.Start)).ToList();
244	var sqllite_programs_startdate_range = sqlite.GetProgramsDateRange(sqllite_programs);
245	var xmltv_programs_startdate_range = GetXMLTVProgramStartDateRange(xmltv_programs);
246	var gbpvr_invalid_programs = new List<SQLLITE.IPROGRAMME>();
247	var gbpvr_valid_programs = sqlite.GetValidPrograms(sqllite_programs, xmltv_programs, out gbpvr_invalid_programs);
248	xmltv_programs = xmltv_programs.OrderBy(s => s.ChannelNumber).ThenBy(s => DateTime.Parse(s.Start)).ToList();
249	//sqllite_channels.TrimExcess();
250	//gbpvr_invalid_programs.TrimExcess();
251	//gbpvr_valid_programs.TrimExcess();
252	//sqllite_programs.TrimExcess();
253	//xmltv_programs.TrimExcess();
254	//CheckScheduledRecordingsForDiscrepancies(sqllite_recordings);
255	//CheckProgramsForDiscrepancies(gbpvr_valid_programs, xmltv_programs);
256	}
257
258	static IDateTimeRange GetXMLTVProgramStartDateRange(List<libxmltv.Interfaces.IProgramDefinition> programs)
259	{
260	IDateTimeRange range = DateTimeRange.Create();
261	var list = new List<libxmltv.Interfaces.IProgramDefinition>(programs.ToArray());
262	DateTime first = new DateTime();
263	DateTime last = new DateTime();
264	first = DateTime.Parse(list.OrderBy(s => DateTime.Parse(s.Start)).ToList().First().Start);
265	last = DateTime.Parse(list.OrderBy(s => DateTime.Parse(s.Start)).ToList().Last().Start);
266	gLog.Info.WriteLine("\tFirst: {0} = ({1})", first.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), first.ToDateTimeString());
267	gLog.Info.WriteLine("\tLast: {0} = ({1})", last.ToString("yyyy/MM/dd HH:mm:ss.fffffff"), last.ToDateTimeString());
268	range = DateTimeRange.Create(first, last);
269	return range;
270	}
271
272	static void CheckScheduledRecordingsForDiscrepancies(List<SQLLITE.IRECORDING_SCHEDULE> gbpvr)
273	{
274	////gLog.Warn.WriteLine("CheckScheduledRecordingsForDiscrepancies() has not been implemented");
275	//var manual_gbpvr_recordings = gbpvr.FindAll(p => p.recording_type == 0).ToList();
276
277	//foreach (var manual_recording in manual_gbpvr_recordings)
278	//{
279	// string title = manual_recording.filename;
280	// DateTime start = manual_recording.manual_start_time;
281	// DateTime end = manual_recording.manual_end_time;
282	// long channel_oid = manual_recording.manual_channel_oid;
283	// var found_channel = gbpvr_channels.Find(p => p.oid == channel_oid);
284	// var channel_number = found_channel.channel_number;
285	// var found_program = xmltv_programs.ToList().Find(p =>
286	// p.Title.ToLower() == title.ToLower() &&
287	// p.Start == start.ToDateTimeString() &&
288	// p.Stop == end.ToDateTimeString() &&
289	// p.ChannelNumber == channel_number
290	// );
291	// if (found_program != null)
292	// {
293	// gLog.Info.WriteLine("Recording might be valid: oid='{0}' programme_oid='{1}' title='{2}' start='{3}', end='{4}'", manual_recording.oid, manual_recording.programme_oid, title, start.ToDateTimeString(), end.ToDateTimeString());
294	// }
295	// else
296	// {
297	// gLog.Warn.WriteLine("Recording may not be valid: oid='{0}' programme_oid='{1}' title='{2}' start='{3}', end='{4}'", manual_recording.oid, manual_recording.programme_oid, title, start.ToDateTimeString(), end.ToDateTimeString());
298	// // find the program on the channel at the start time
299	// var correct_program = xmltv_programs.ToList().Find(p =>
300	// p.ChannelNumber == channel_number &&
301	// p.Start == start.ToDateTimeString()
302	// );
303	// if (correct_program != null)
304	// {
305	// gLog.Warn.WriteLine("\tThis will be recorded: {0}", correct_program.ToString());
306	// }
307	// }
308	//}
309	}
310
311	static void CheckProgramsForDiscrepancies(List<SQLLITE.IPROGRAMME> list_gbpvr, List<libxmltv.Interfaces.IProgramDefinition> list_xmltv)
312	{
313	////gLog.Warn.WriteLine("CheckProgramsForDiscrepancies() has not been implemented");
314	//var gbpvr = list_gbpvr.ToArray();
315	//var xmltv = list_xmltv.ToArray();
316	////if (gbpvr.Count() != xmltv.Count())
317	////{
318	//// throw new ArgumentOutOfRangeException("gbpvr.Count/xmltv.Count", string.Format("gbpvr.Count: '0x{0:x8}' != xmltv.Count: '0x{1:x8}'", gbpvr.Count(),xmltv.Count()));
319	////}
320	////for (int i = 0; i < gbpvr.Count(); i++)
321	////{
322	//// var gbpvr_entry = gbpvr[i];
323	//// var xmltv_entry = gbpvr_entry.AsXMLTVProgramDefinition(sqlite);
324	//// if (!xmltv[i].Equals(xmltv_entry))
325	//// {
326	//// gLog.Warn.WriteLine("Warning GBPVR Program oid: {0} might be invalid", gbpvr_entry.oid);
327	//// }
328	////}
329	}
330	}
331	}