using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
using skyscraper5.Docsis.MacManagement;
using skyscraper5.DsmCc.Descriptors;
using skyscraper5.Dvb.DataBroadcasting.IntModel;
using skyscraper5.Dvb.DataBroadcasting.SkyscraperVfs;
using skyscraper5.Dvb.Descriptors;
using skyscraper5.Dvb.Psi.Model;
using skyscraper5.Dvb.SystemSoftwareUpdate.Model;
using skyscraper5.Dvb.TvAnytime;
using skyscraper5.Mhp.Si;
using skyscraper5.Mhp.Si.Model;
using skyscraper5.Mpeg2.Descriptors;
using skyscraper5.Mpeg2.Psi.Model;
using skyscraper5.Rds.Messages;
using skyscraper5.Scte35;
using skyscraper5.Skyscraper.Equipment;
using skyscraper5.Skyscraper.Gps;
using skyscraper5.Skyscraper.Headless;
using skyscraper5.Skyscraper.IO.CrazycatStreamReader;
using skyscraper5.Skyscraper.Scraper.Storage.Utilities;
using skyscraper5.src.InteractionChannel.Model;
using skyscraper5.src.InteractionChannel.Model.Descriptors;
using skyscraper5.src.Skyscraper.FrequencyListGenerator;
using skyscraper5.src.Skyscraper.Scraper.Dns;
using skyscraper5.Teletext;
using skyscraper8.DvbI;
using skyscraper8.Ses;
using Platform = skyscraper5.Dvb.SystemSoftwareUpdate.Model.Platform;

namespace skyscraper5.Skyscraper.Scraper.Storage.Split
{
	public class SplitScraperStorage : IScraperStroage
    {
        private readonly DataStorage dataStorage;
        private readonly ObjectStorage objectStorage;

        public SplitScraperStorage(DataStorage dataStorage, ObjectStorage objectStorage)
        {
            this.dataStorage = dataStorage;
            this.objectStorage = objectStorage;
        }

        [DebuggerStepThrough]
        public bool TestForNitNetwork(NitNetwork nitNetwork)
        {
            return dataStorage.TestForNitNetwork(nitNetwork);
        }

        [DebuggerStepThrough]
        public void StoreNitNetwork(NitNetwork nitNetwork)
        {
            dataStorage.StoreNitNetwork(nitNetwork);
        }

        [DebuggerStepThrough]
        public bool UpdateNitNetwork(NitNetwork nitNetwork)
        {
            return dataStorage.UpdateNitNetwork(nitNetwork);
        }

        [DebuggerStepThrough]
        public bool TestForNitTransportStream(ushort networkId, NitTransportStream transportStream)
        {
            return dataStorage.TestForNitTransportStream(networkId, transportStream);
        }

        [DebuggerStepThrough]
        public void StoreNitTransportStream(ushort networkId, NitTransportStream transportStream)
        {
            dataStorage.StoreNitTransportStream(networkId, transportStream);
        }

        [DebuggerStepThrough]
        public bool UpdateNitTransportStream(ushort networkId, NitTransportStream transportStream)
        {
            return dataStorage.UpdateNitTransportStream(networkId, transportStream);
        }

        [DebuggerStepThrough]
        public bool StorePatEntry(int currentNetworkId, int currentTransportStreamId, int pmtPid, ushort programId)
        {
            return dataStorage.StorePatEntry(currentNetworkId, currentTransportStreamId, pmtPid, programId);
        }

        [DebuggerStepThrough]
        public bool TestForPmtEvent(int currentNetworkId, int currentTransportStreamId, ProgramMapping result)
        {
            return dataStorage.TestForPmtEvent(currentNetworkId, currentTransportStreamId, result);
        }

        [DebuggerStepThrough]
        public bool StorePmtEvent(int currentNetworkId, int currentTransportStreamId, ProgramMapping mapping)
        {
            return dataStorage.StorePmtEvent(currentNetworkId, currentTransportStreamId, mapping);
        }

        public bool StoreTeletextPage(int networkId, int transportStreamId, ushort programNumber, TeletextMagazine magazine, DateTime timestamp)
        {
            if (magazine.HumanReadablePageNumber > 999)
                return false;

            return dataStorage.StoreTeletextPage(networkId, transportStreamId, programNumber, magazine, timestamp);
        }
        
        [DebuggerStepThrough]
        public bool TestForSdtService(ushort transportStreamId, ushort originalNetworkId, SdtService sdtService)
        {
            return dataStorage.TestForSdtService(transportStreamId, originalNetworkId, sdtService);
        }
        
        [DebuggerStepThrough]
        public bool UpdateSdtService(ushort transportStreamId, ushort originalNetworkId, SdtService sdtService)
        {
            return dataStorage.UpdateSdtService(transportStreamId, originalNetworkId, sdtService);
        }

        [DebuggerStepThrough]
        public void StoreSdtService(ushort transportStreamId, ushort originalNetworkId, SdtService sdtService)
        {
            dataStorage.StoreSdtService(transportStreamId, originalNetworkId, sdtService);
        }

        [DebuggerStepThrough]
        public bool TestForBatBouquet(BatBouquet batBouquet)
        {
            return dataStorage.TestForBatBouquet(batBouquet);
        }

        [DebuggerStepThrough]
        public bool UpdateBatBouquet(BatBouquet batBouquet)
        {
            return dataStorage.UpdateBatBouquet(batBouquet);
        }

        [DebuggerStepThrough]
        public void StoreBatBouquet(BatBouquet batBouquet)
        {
            dataStorage.StoreBatBouquet(batBouquet);
        }

        [DebuggerStepThrough]
        public bool TestForBatTransportStream(ushort batBouquetBouquetId, BatTransportStream child)
        {
            return dataStorage.TestForBatTransportStream(batBouquetBouquetId, child);
        }

        [DebuggerStepThrough]
        public bool UpdateBatTransportStream(ushort batBouquetBouquetId, BatTransportStream child)
        {
            return dataStorage.UpdateBatTransportStream(batBouquetBouquetId, child);
        }

        [DebuggerStepThrough]
        public void StoreBatTransportStream(ushort batBouquetBouquetId, BatTransportStream child)
        {
            dataStorage.StoreBatTransportStream(batBouquetBouquetId, child);
        }

        [DebuggerStepThrough]
        public bool UpdateTimeOffsetTable(int currentNetworkId, int currentTransportStreamId, DateTime utcTime, LocalTimeOffsetDescriptor ltod)
        {
            return dataStorage.UpdateTimeOffsetTable(currentNetworkId, currentTransportStreamId, utcTime, ltod);
        }

        [DebuggerStepThrough]
        public bool UpdateTimeAndDate(int currentNetworkId, int currentTransportStreamId, DateTime utcTime)
        {
            return dataStorage.UpdateTimeAndDate(currentNetworkId, currentTransportStreamId, utcTime);
        }

        [DebuggerStepThrough]
        public bool StoreEitEvent(EitEvent eitEvent)
        {
            return dataStorage.StoreEitEvent(eitEvent);
        }

        [DebuggerStepThrough]
        public bool TestForAitApplication(ApplicationIdentifier aitApplicationApplicationIdentifier)
        {
            return dataStorage.TestForAitApplication(aitApplicationApplicationIdentifier);
        }

        [DebuggerStepThrough]
        public void StoreAitApplication(AitApplication aitApplication)
        {
            dataStorage.StoreAitApplication(aitApplication);
        }

        [DebuggerStepThrough]
        public bool ObjectCarouselFileArrival(VfsFile vfsFile, int transportStreamId, int networkId)
        {
            return objectStorage.ObjectCarouselFileArrival(vfsFile, transportStreamId, networkId);
        }

        [DebuggerStepThrough]
        public bool TestForCaSystem(int currentNetworkId, int currentTransportStreamId, int caDescriptorCaPid)
        {
            return dataStorage.TestForCaSystem(currentNetworkId, currentTransportStreamId, caDescriptorCaPid);
        }

        [DebuggerStepThrough]
        public void StoreCaSystem(int currentNetworkId, int currentTransportStreamId, CaDescriptor caDescriptor)
        {
            dataStorage.StoreCaSystem(currentNetworkId, currentTransportStreamId, caDescriptor);
        }

        [DebuggerStepThrough]
        public void StoreUpdateNotification(int hashCode, UpdateNotificationGroup common, Compatibility compatibility, Platform platform)
        {
            dataStorage.StoreUpdateNotification(hashCode, common, compatibility, platform);
        }

        [DebuggerStepThrough]
        public void DataCarouselModuleArrival(int currentNetworkId, int currentTransportStreamId, int elementaryPid, ushort moduleModuleId, byte moduleModuleVersion, Stream result)
        {
            objectStorage.DataCarouselModuleArrival(currentNetworkId, currentTransportStreamId, elementaryPid, moduleModuleId, moduleModuleVersion, result);
        }

        [DebuggerStepThrough]
        public bool TestForKnownRdsData(int currentNetworkId, int currentTransportStreamId, int programNumber)
        {
            return dataStorage.TestForKnownRdsData(currentNetworkId, currentTransportStreamId, programNumber);
        }

        [DebuggerStepThrough]
        public void EnableRdsCollection(int currentNetworkId, int currentTransportStreamId, int programNumber)
        {
            dataStorage.EnableRdsCollection(currentNetworkId, currentTransportStreamId, programNumber);
        }

        [DebuggerStepThrough]
        public bool UpdateRdsProgrammeServiceName(int currentNetworkId, int currentTransportStreamId, int programNumber, string programmeService2)
        {
            return dataStorage.UpdateRdsProgrammeServiceName(currentNetworkId, currentTransportStreamId, programNumber, programmeService2);
        }

        [DebuggerStepThrough]
        public bool UpdateRdsRadioText(int currentNetworkId, int currentTransportStreamId, int programNumber, string text)
        {
            return dataStorage.UpdateRdsRadioText(currentNetworkId, currentTransportStreamId, programNumber, text);
        }

        [DebuggerStepThrough]
        public bool UpdateRdsPty(int currentNetworkId, int currentTransportStreamId, int programNumber, PTY.ProgrammeTypeCodes pty)
        {
            return dataStorage.UpdateRdsPty(currentNetworkId, currentTransportStreamId, programNumber, pty);
        }

        [DebuggerStepThrough]
        public bool MarkAsRdsTrafficInformationProgramme(int currentNetworkId, int currentTransportStreamId, int programNumber)
        {
            return dataStorage.MarkAsRdsTrafficInformationProgramme(currentNetworkId, currentTransportStreamId, programNumber);
        }

        [DebuggerStepThrough]
        public bool TestForScte35SpliceInsert(int currentNetworkId, int currentTransportStreamId, ushort programNumber, SpliceInsert spliceInsert)
        {
            return dataStorage.TestForScte35SpliceInsert(currentNetworkId, currentTransportStreamId, programNumber, spliceInsert);
        }

        [DebuggerStepThrough]
        public void StoreScte35SpliceInsert(int currentNetworkId, int currentTransportStreamId, ushort programNumber, SpliceInsert spliceInsert)
        {
            dataStorage.StoreScte35SpliceInsert(currentNetworkId, currentTransportStreamId, programNumber, spliceInsert);
        }

        [DebuggerStepThrough]
        public bool IsCompliant(int currentNetworkId, int currentTransportStreamId, string compliance)
        {
            return dataStorage.IsCompliant(currentNetworkId, currentTransportStreamId, compliance);
        }

        [DebuggerStepThrough]
        public void MarkAsCompliant(int currentNetworkId, int currentTransportStreamId, string compliance)
        {
            dataStorage.MarkAsCompliant(currentNetworkId, currentTransportStreamId, compliance);
        }

        [DebuggerStepThrough]
        public bool SetStationIdentification(int currentNetworkId, int currentTransportStreamId, string stationIdentification)
        {
            return dataStorage.SetStationIdentification(currentNetworkId, currentTransportStreamId, stationIdentification);
        }
        
        [DebuggerStepThrough]
        public bool IsDsmCcModuleWanted(int currentNetworkId, int currentTransportStreamId, int elementaryPid, ushort moduleId, byte moduleVersion)
        {
            return objectStorage.IsDsmCcModuleWanted(currentNetworkId, currentTransportStreamId, elementaryPid, moduleId, moduleVersion);
        }

        [DebuggerStepThrough]
        public void StoreDsmCcDoItNowEvent(DateTime value, int currentNetworkId, int currentTransportStreamId, int programNumber, StreamEventDescriptor descriptorListStreamEventDescriptor, int pid)
        {
            dataStorage.StoreDsmCcDoItNowEvent(value, currentNetworkId, currentTransportStreamId, programNumber, descriptorListStreamEventDescriptor, pid);
        }

        [DebuggerStepThrough]
        public bool StoreRunningStatus(uint transportStreamId, uint originalNetworkId, uint serviceId, uint eventId, RunningStatus runningStatus, DateTime currentTime)
        {
            return dataStorage.StoreRunningStatus(transportStreamId, originalNetworkId, serviceId, eventId, runningStatus, currentTime);
        }
        
        [DebuggerStepThrough]
        public void SetScte35TimeSignal(int currentNetworkId, int currentTransportStreamId, DateTime currentTime, ushort programNumber, TimeSignal timeSignal)
        {
            dataStorage.SetScte35TimeSignal(currentNetworkId, currentTransportStreamId, currentTime, programNumber, timeSignal);
        }

        [DebuggerStepThrough]
        public bool TestForFramegrab(int currentNetworkId, int transportStreamId, ushort mappingProgramNumber, int mappingStreamElementaryPid)
        {
            return objectStorage.TestForFramegrab(currentNetworkId, transportStreamId, mappingProgramNumber, mappingStreamElementaryPid);
        }

        [DebuggerStepThrough]
        public bool TestForIpMacNotification(IpMacNotification notification)
        {
            return dataStorage.TestForIpMacNotification(notification);
        }

        [DebuggerStepThrough]
        public void StoreIpMacNotification(IpMacNotification notification)
        {
            dataStorage.StoreIpMacNotification(notification);
        }

        [DebuggerStepThrough]
        public bool ImportFileKnown(FileInfo fi)
        {
            return dataStorage.ImportFileKnown(fi);
        }

        [DebuggerStepThrough]
        public void ImportMarkFileAsKnown(FileInfo fi, TimeSpan timeTaken, int tstype)
        {
            dataStorage.ImportMarkFileAsKnown(fi, timeTaken, tstype);
        }

        [DebuggerStepThrough]
        public DateTime T2MiGetTimestamp(int currentNetworkId, int currentTransportStreamId, int pid)
        {
            return dataStorage.T2MiGetTimestamp(currentNetworkId, currentTransportStreamId, pid);
        }

        [DebuggerStepThrough]
        public void T2MiSetTimestamp(int currentNetworkId, int currentTransportStreamId, int pid, DateTime resolveTime)
        {
            dataStorage.T2MiSetTimestamp(currentNetworkId, currentTransportStreamId, pid, resolveTime);
        }

        [DebuggerStepThrough]
        public bool TestForRelatedContent(EitEvent lEvent, RctLinkInfo rctLinkInfo)
        {
            return dataStorage.TestForRelatedContent(lEvent, rctLinkInfo);
        }

        [DebuggerStepThrough]
        public void SetRelatedContent(EitEvent lEvent, RctLinkInfo rctLinkInfo)
        {
            dataStorage.SetRelatedContent(lEvent, rctLinkInfo);
        }

        [DebuggerStepThrough]
        public List<SatellitePosition> UiSatellitesListAll()
        {
            return dataStorage.UiSatellitesListAll();
        }

        [DebuggerStepThrough]
        public void UiSatellitesAdd(SatellitePosition newPosition)
        {
            dataStorage.UiSatellitesAdd(newPosition);
        }

        [DebuggerStepThrough]
        public void UiSatellitesDelete(SatellitePosition satellitePosition)
        {
            dataStorage.UiSatellitesDelete(satellitePosition);
        }

        [DebuggerStepThrough]
        public bool UiTunerTestFor(TunerMetadata tuner)
        {
            return dataStorage.UiTunerTestFor(tuner);
        }

        [DebuggerStepThrough]
        public void UiTunerUpdate(TunerMetadata tuner)
        {
            dataStorage.UiTunerUpdate(tuner);
        }

        [DebuggerStepThrough]
        public void UiTunerInsert(TunerMetadata tuner)
        {
            dataStorage.UiTunerInsert(tuner);
        }

        [DebuggerStepThrough]
        public void UiTunerGetConfiguration(TunerMetadata foundTuner)
        {
            dataStorage.UiTunerGetConfiguration(foundTuner);
        }

        [DebuggerStepThrough]
        public void StoreFramegrab(int currentNetworkId, int transportStreamId, ushort mappingProgramNumber, ushort pid, byte[] imageData)
        {
            objectStorage.StoreFramegrab(currentNetworkId, transportStreamId, mappingProgramNumber, pid, imageData);
        }

        [DebuggerStepThrough]
        public bool TestForDocsisUpstreamChannel(PhysicalAddress mmmSource, uint mmmFrequency, int locationId)
        {
            return dataStorage.TestForDocsisUpstreamChannel(mmmSource, mmmFrequency, locationId);
        }

        [DebuggerStepThrough]
        public void StoreDocsisUpstreamChannel(UpstreamChannelDescriptor mmm, int locationId)
        {
            dataStorage.StoreDocsisUpstreamChannel(mmm, locationId);
        }

        [DebuggerStepThrough]
        public bool TestForDocsisDownstreamChannel(PhysicalAddress physicalAddress, MacDomainDescriptor.DownstreamActiveChannel downstreamActiveChannel, int locationId)
        {
            return dataStorage.TestForDocsisDownstreamChannel(physicalAddress, downstreamActiveChannel,locationId);
        }

        [DebuggerStepThrough]
        public void StoreDocsisDownstreamChannel(PhysicalAddress physicalAddress, MacDomainDescriptor.DownstreamActiveChannel downstreamActiveChannel, int locationId)
        {
            dataStorage.StoreDocsisDownstreamChannel(physicalAddress, downstreamActiveChannel,locationId);
        }

        [DebuggerStepThrough]
        public bool SetCmtsIp(PhysicalAddress arpHeaderSenderHardwareAddress, IPAddress arpHeaderSenderProtocolAddress)
        {
           return dataStorage.SetCmtsIp(arpHeaderSenderHardwareAddress, arpHeaderSenderProtocolAddress);
        }

        [DebuggerStepThrough]
        public bool IsDsmCcModuleBlacklisted(int currentNetworkId, int currentTransportStreamId, int elementaryPid, ushort moduleId,
            byte moduleVersion)
        {
            return dataStorage.IsDsmCcModuleBlacklisted(currentNetworkId, currentTransportStreamId, elementaryPid, moduleId, moduleVersion);
        }

        [DebuggerStepThrough]
        public int? GetCurrentLocationId()
        {
            return dataStorage.GetCurrentLocationId();
        }

		[DebuggerStepThrough]
        public void StoreDocsisParticipant(PhysicalAddress pa, int currentLocation)
        {
            dataStorage.StoreDocsisParticipant(pa, currentLocation);
        }

        [DebuggerStepThrough]
        public HeadlessJob GetQueuedJob()
        {
            return dataStorage.GetQueuedJob();
        }

        [DebuggerStepThrough]
        public void SetQueuedJobComplete(HeadlessJob headlessJob)
        {
            dataStorage.SetQueuedJobComplete(headlessJob);
        }

        [DebuggerStepThrough]
        public void WaitForCompletion()
        {
            dataStorage.WaitForCompletion();
            objectStorage.WaitForCompletion();
        }

        [DebuggerStepThrough]
        public void UiSetVersion(int version)
        {
            dataStorage.UiSetVersion(version);
            objectStorage.UiSetVersion(version);
        }

        [DebuggerStepThrough]
        public bool T2MiTestForTransmitter(int? currentNetworkId, int? currentTransportStreamId, int relatedPid, ushort txIdentifier)
        {
            return dataStorage.T2MiTestForTransmitter(currentNetworkId, currentTransportStreamId, relatedPid, txIdentifier);
        }

        [DebuggerStepThrough]
        public void T2MiRememberTransmitter(int? currentNetworkId, int? currentTransportStreamId, int relatedPid, ushort txIdentifier)
        {
            dataStorage.T2MiRememberTransmitter(currentNetworkId, currentTransportStreamId, relatedPid, txIdentifier);
        }

        [DebuggerStepThrough]
        public void T2MiSetTransmitterTimeOffset(int? currentNetworkId, int? currentTransportStreamId, int relatedPid, ushort txIdentifier, ushort timeOffset)
        {
            dataStorage.T2MiSetTransmitterTimeOffset(currentNetworkId, currentTransportStreamId, relatedPid, txIdentifier, timeOffset);
        }

        [DebuggerStepThrough]
		public List<LnbType> UiLnbTypesListAll()
        {
	        return dataStorage.UiLnbTypesListAll();
        }

		[DebuggerStepThrough]
		public void UiLnbTypesAdd(LnbType defaultLnbType)
        {
	        dataStorage.UiLnbTypesAdd(defaultLnbType);
        }

		[DebuggerStepThrough]
		public List<DishType> UiDishTypesListAll()
        {
	        return dataStorage.UiDishTypesListAll();
        }

		[DebuggerStepThrough]
		public void UiDishTypesAdd(DishType defaultDishType)
        {
	        dataStorage.UiDishTypesAdd(defaultDishType);
        }

        public object[] GetPluginConnector()
        {
	        object[] dataConnector = dataStorage.GetPluginConnector();
	        object[] objectConnector = objectStorage.GetPluginConnector();

	        if (dataConnector != null && objectConnector == null)
		        return dataConnector;

	        if (dataConnector == null && objectConnector != null)
		        return objectConnector;
            
	        object[] result = new object[dataConnector.Length + objectConnector.Length];
	        Array.Copy(dataConnector, 0, result, 0, dataConnector.Length);
	        Array.Copy(objectConnector, 0, result, dataConnector.Length, objectConnector.Length);
	        return result;
        }

        [DebuggerStepThrough]
		public void Ping()
        {
	        dataStorage.Ping();
	        objectStorage.Ping();
        }

		[DebuggerStepThrough]
		public IEnumerable<Tuple<int, int, ProgramMapping>> SelectAllPmt()
        {
	        return dataStorage.SelectAllPmt();
        }

		[DebuggerStepThrough]
		public SdtService SelectSdtById(int networkId, int tsId, ushort programMappingProgramNumber)
        {
	        return dataStorage.SelectSdtById(networkId, tsId, programMappingProgramNumber);
        }

        [DebuggerStepThrough]
		public IEnumerable<Tuple<int, int, SdtService>> SelectAllSdt()
		{
			return dataStorage.SelectAllSdt();
		}

        [DebuggerStepThrough]
		public void BeamsDisableAll()
		{
			dataStorage.BeamsDisableAll();
		}

		[DebuggerStepThrough]
		public void BeamsEnable(int id, float satpos, string name, DateTime processTimestamp)
		{
			dataStorage.BeamsEnable(id, satpos, name, processTimestamp);
		}

		[DebuggerStepThrough]
		public void BeamFootprintStore(int databasePointerId, DateTime databasePointerBeamsProcessTimestamp, string name,
			string getPolygonString, string id)
		{
			dataStorage.BeamFootprintStore(databasePointerId, databasePointerBeamsProcessTimestamp, name, getPolygonString, id);
		}

        [DebuggerStepThrough]
		public bool TestForBeamFootprint(int databasePointerId, DateTime databasePointerBeamsProcessTimestamp, string name, string id)
		{
			return dataStorage.TestForBeamFootprint(databasePointerId, databasePointerBeamsProcessTimestamp, name, id);
		}

        [DebuggerStepThrough]
		public void BeamsDisableSpecific(int databasePointerId, float databasePointerSatpos, string databasePointerName,
			DateTime databasePointerBeamsProcessTimestamp)
		{
			dataStorage.BeamsDisableSpecific(databasePointerId, databasePointerSatpos, databasePointerName, databasePointerBeamsProcessTimestamp);
		}

        [DebuggerStepThrough]
		public IEnumerable<SatelliteBeam> BeamsSelectEnabled()
		{
			return dataStorage.BeamsSelectEnabled();
		}

        [DebuggerStepThrough]
		public List<SatelliteBeamFootprint> BeamsSelectFootprints(int satelliteBeamId, DateTime satelliteBeamProcessTimestamp)
		{
			return dataStorage.BeamsSelectFootprints(satelliteBeamId, satelliteBeamProcessTimestamp);
		}

        [DebuggerStepThrough]
		public void InsertBlindscanJob(DbBlindscanJob jobInDb)
		{
			dataStorage.InsertBlindscanJob(jobInDb);
		}

        [DebuggerStepThrough]
		public void UpdateJobState(DbBlindscanJob jobInDb)
		{
			dataStorage.UpdateJobState(jobInDb);
		}

        [DebuggerStepThrough]
		public void InsertSearchResult(DbBlindscanJob jobInDb, bool satellite, SearchResult searchResult, int polarityIndex,
			SearchResult2 searchResult2)
		{
			dataStorage.InsertSearchResult(jobInDb, satellite, searchResult, polarityIndex, searchResult2);
		}

        [DebuggerStepThrough]
		public void UpdateTransponderState(DbBlindscanJob jobInDb, bool satellite, SearchResult searchResult,
			BlindscanResultState blindscanResultState, SearchResult2 searchResult2)
		{
			dataStorage.UpdateTransponderState(jobInDb, satellite, searchResult, blindscanResultState, searchResult2);
		}

		[DebuggerStepThrough]
		public void InsertTransponderService(DbBlindscanJob jobInDb, bool resultSatellite, SearchResult resultSr1,
			SearchResult2 resultSr2, HumanReadableService humanReadableService)
		{
			dataStorage.InsertTransponderService(jobInDb, resultSatellite, resultSr1, resultSr2, humanReadableService);
		}

		[DebuggerStepThrough]
		public bool TestForIncompleteJob()
		{
			return dataStorage.TestForIncompleteJob();
		}

		[DebuggerStepThrough]
		public DbBlindscanJob GetPastBlindscanJob(long offset)
		{
			return dataStorage.GetPastBlindscanJob(offset);
		}

        [DebuggerStepThrough]
		public void DeleteBlindscanJob(Guid guid)
		{
            dataStorage.DeleteBlindscanJob(guid);
		}

        [DebuggerStepThrough]
		public void DeleteBlindscanResults(Guid jobGuid, int polarityIndex)
		{
            dataStorage.DeleteBlindscanResults(jobGuid, polarityIndex);
		}

        [DebuggerStepThrough]
		public void MoveBlScanResultsToAnotherJob(Guid moveFrom, Guid moveTo, int polarityIndex)
		{
            dataStorage.MoveBlScanResultsToAnotherJob(moveFrom, moveTo, polarityIndex);
		}

        [DebuggerStepThrough]
		public void FailDsmCcDownload(DatabaseKeyDsmCcModule key, double value)
		{
            dataStorage.FailDsmCcDownload(key, value);
		}

        [DebuggerStepThrough]
		public IReadOnlyList<string> ListImportFileByTag1(int tag1)
		{
            return dataStorage.ListImportFileByTag1(tag1);
		}

		[DebuggerStepThrough]
		public bool TestForTerminalBurstTimePlan(ushort interactiveNetworkId, uint groupId, uint logonId)
		{
            return dataStorage.TestForTerminalBurstTimePlan(interactiveNetworkId, groupId, logonId);
		}

		[DebuggerStepThrough]
		public void StoreTerminalBurstTimePlan(ushort interactiveNetworkId, uint gtoupId, uint superframeCount, uint frameNumber, Tbtp.TbtpFrame.BtpEntity btp)
		{
            dataStorage.StoreTerminalBurstTimePlan(interactiveNetworkId, gtoupId, superframeCount, frameNumber, btp);
		}

		[DebuggerStepThrough]
		public bool TestForCmtEntry(ushort interactiveNetworkId, Cmt.CmtEntry entry)
		{
            return dataStorage.TestForCmtEntry(interactiveNetworkId, entry);
		}

		[DebuggerStepThrough]
		public void InsertCmtEntry(ushort interactiveNetworkId, Cmt.CmtEntry entry)
		{
            dataStorage.InsertCmtEntry(interactiveNetworkId, entry);
		}

        [DebuggerStepThrough]
		public int GetRmtTransmissionStandard(ushort networkId)
		{
            return dataStorage.GetRmtTransmissionStandard(networkId);
		}

        [DebuggerStepThrough]
		public byte[] GetTmst(ushort interactiveNetworkId)
		{
            return dataStorage.GetTmst(interactiveNetworkId);
		}

		[DebuggerStepThrough]
		public void InsertTmst(ushort interactiveNetworkId, byte[] modes)
		{
            dataStorage.InsertTmst(interactiveNetworkId, modes);
		}

		[DebuggerStepThrough]
		public void UpdateTmst(ushort interactiveNetworkId, byte[] modes)
		{
            dataStorage.UpdateTmst(interactiveNetworkId, modes);
		}

		[DebuggerStepThrough]
		public bool TestForRmtLinkage(_0x4a_LinkageDescriptor linkage)
		{
            return dataStorage.TestForRmtLinkage(linkage);
		}

		[DebuggerStepThrough]
		public void InsertRmtLinkage(_0x4a_LinkageDescriptor linkage)
		{
            dataStorage.InsertRmtLinkage(linkage);
		}

		[DebuggerStepThrough]
		public bool TestForRmtTransportStream(ushort networkId, Rmt.TransportStream transportStream)
		{
            return dataStorage.TestForRmtTransportStream(networkId, transportStream);
		}

		[DebuggerStepThrough]
		public void InsertRmtTransportStream(ushort networkId, Rmt.TransportStream transportStream)
		{
            dataStorage.InsertRmtTransportStream(networkId, transportStream);
		}

        [DebuggerStepThrough]
		public bool TestForSuperframeComposition(ushort interactiveNetworkId, Sct.Superframe superframe)
		{
            return dataStorage.TestForSuperframeComposition(interactiveNetworkId, superframe);
		}

		[DebuggerStepThrough]
		public void StoreSuperframeComposition(ushort interactiveNetworkId, Sct.Superframe superframe)
		{
            dataStorage.StoreSuperframeComposition(interactiveNetworkId, superframe);
		}

		[DebuggerStepThrough]
		public bool TestForFrameComposition(ushort interactiveNetworkId, Fct.Frame frame)
		{
            return dataStorage.TestForFrameComposition(interactiveNetworkId, frame);
		}

		[DebuggerStepThrough]
		public void InsertFctFrame(ushort interactiveNetworkId, Fct.Frame frame)
		{
            dataStorage.InsertFctFrame(interactiveNetworkId, frame);
		}

		[DebuggerStepThrough]
		public bool TestForSatellitePosition(ushort interactiveNetworkId, Spt.Satellite satellite)
		{
            return dataStorage.TestForSatellitePosition(interactiveNetworkId, satellite);
		}

		[DebuggerStepThrough]
		public void StoreSatellitePosition(ushort interactiveNetworkId, Spt.Satellite satellite)
		{
            dataStorage.StoreSatellitePosition(interactiveNetworkId, satellite);
		}

		[DebuggerStepThrough]
		public bool TestForTim(PhysicalAddress mac)
		{
            return dataStorage.TestForTim(mac);
		}

		[DebuggerStepThrough]
		public void CreateTim(PhysicalAddress mac)
		{
            dataStorage.CreateTim(mac);
		}

		[DebuggerStepThrough]
		public bool CorrectTim(PhysicalAddress mac, _0xa1_CorrectionMessageDescriptor cmd)
		{
            return dataStorage.CorrectTim(mac, cmd);
		}

        [DebuggerStepThrough]
		public bool ContentionTim(PhysicalAddress mac, _0xab_ContentionControlDescriptor ccdNew)
		{
            return dataStorage.ContentionTim(mac, ccdNew);
		}

        [DebuggerStepThrough]
		public bool CorrectionControlTim(PhysicalAddress mac, _0xac_CorrectionControlDescriptor descriptor)
		{
            return dataStorage.CorrectionControlTim(mac, descriptor);
		}

        [DebuggerStepThrough]
		public bool NetworkLayerInfoTim(PhysicalAddress mac, _0xa0_NetworkLayerInfoDescriptor nlid, DateTime timestamped)
		{
			return dataStorage.NetworkLayerInfoTim(mac, nlid, timestamped);
		}

        [DebuggerStepThrough]
		public IEnumerable<DbBlindscanJob> GetDbBlindscanJobs()
        {
            return dataStorage.GetDbBlindscanJobs();
        }

        [DebuggerStepThrough]
		public long DnsCountA()
		{
            return dataStorage.DnsCountA();
		}

        [DebuggerStepThrough]
		public string DnsIpToName(IPAddress source)
		{
            return dataStorage.DnsIpToName(source);
		}

        [DebuggerStepThrough]
		public bool TestForIp(IPAddress iP)
		{
            return dataStorage.TestForIp(iP);
		}

        [DebuggerStepThrough]
		public void RememberDnsRecord(DnsRecord record)
		{
            dataStorage.RememberDnsRecord(record);
		}

		[DebuggerStepThrough]
		public bool TestForSgtList(SgtList list)
		{
            return dataStorage.TestForSgtList(list);
		}
        
		[DebuggerStepThrough]
		public void InsertSgtList(SgtList list)
		{
            dataStorage.InsertSgtList(list);
		}

		[DebuggerStepThrough]
		public bool TestForSgtService(SgtService child)
		{
            return dataStorage.TestForSgtService(child);
		}

		[DebuggerStepThrough]
		public void InsertSgtService(SgtService child)
		{
            dataStorage.InsertSgtService(child);
		}

		[DebuggerStepThrough]
		public void InsertDvbiServiceListEntryPoint(long sourceHash)
		{
            dataStorage.InsertDvbiServiceListEntryPoint(sourceHash);
		}

		[DebuggerStepThrough]
		public bool TestForServiceListEntryPoints(long sourceHash)
		{
            return dataStorage.TestForServiceListEntryPoints(sourceHash);
		}

		[DebuggerStepThrough]
		public void InsertDvbiServiceList(DvbiServiceList serviceList)
		{
            dataStorage.InsertDvbiServiceList(serviceList);
		}

		[DebuggerStepThrough]
		public bool TestForDvbiService(string id)
		{
            return dataStorage.TestForDvbiService(id);
		}

		[DebuggerStepThrough]
		public bool TestForDvbiServiceListEntryPoints(long sourceHash)
		{
            return dataStorage.TestForDvbiServiceListEntryPoints(sourceHash);
		}

		[DebuggerStepThrough]
		public void UpdateDvbiServiceListLastCheckedDate(string id, DateTime currentTime)
		{
            dataStorage.UpdateDvbiServiceListLastCheckedDate(id, currentTime);
		}

		[DebuggerStepThrough]
		public DateTime GetLastDvbiServiceListEntryPointUpdateDate(long sourceHash)
		{
            return dataStorage.GetLastDvbiServiceListEntryPointUpdateDate(sourceHash);
		}

		[DebuggerStepThrough]
		public DateTime GetDvbiServiceListLastUpdateDate(string id)
		{
            return dataStorage.GetDvbiServiceListLastUpdateDate(id);
		}

		[DebuggerStepThrough]
		public void AddDvbiServiceListToServiceListEntryPoint(DvbiServiceList serviceList, long sourceHash)
		{
            dataStorage.AddDvbiServiceListToServiceListEntryPoint(serviceList, sourceHash);
		}

        [DebuggerStepThrough]
		public void AddDvbiServiceToServiceList(string id, string serviceListId)
		{
            dataStorage.AddDvbiServiceToServiceList(id, serviceListId);
		}

		[DebuggerStepThrough]
		public int GetDvbiServiceVersion(string id)
		{
            return dataStorage.GetDvbiServiceVersion(id);
		}

		[DebuggerStepThrough]
		public void UpdateDvbiService(DvbIService service)
		{
            dataStorage.UpdateDvbiService(service);
		}

		[DebuggerStepThrough]
		public void UpdateDvbiServiceListEntryPointUpdateDate(long hash, DateTime currentTime)
		{
			dataStorage.UpdateDvbiServiceListEntryPointUpdateDate(hash, currentTime);
		}

		[DebuggerStepThrough]
		public void InsertDvbiService(DvbIService service)
		{
            dataStorage.InsertDvbiService(service);
		}

		[DebuggerStepThrough]
		public bool TestForDvbiServiceList(string id)
		{
            return dataStorage.TestForDvbiServiceList(id);
		}
	}
}
