public AudioFileOption(AudioLibraryFile libraryFile, TokensCollection tokens)
        {
            _LibraryFile = libraryFile;
            _LSRTokens   = tokens;

            _ScoringTokenCount = 0;

            _ArtistAlbumPoints = 0;
            _TrackPoints       = 0;
            _BonusPoints       = 0;

            _HasScoredTrackNumber = false;

            _RemainingChars = _LibraryFile.NormalizedSubDirectoriesFilePath;

            _AccuracyScore = 0;

            _IsPossiblyWrongCycle            = false;
            _IsPossiblyWrongAirline          = false;
            _IsPossiblyWrongTrackNumber      = false;
            _IsPossiblyWrongArtistAlbum      = false;
            _IsPossiblyWrongTrackNumberTrack = false;

            _IsOptionFinished = false;
        }
        private static AudioFileOptions Track_Pass1(AudioLibrary audioLibrary, TokensCollection tokens)
        {
            //Backwards Search
            AudioFileOptions pass1 = new AudioFileOptions();

            foreach (AudioLibraryFile file in audioLibrary.GetAudioLibraryFiles)
            {
                AudioFileOption newOption = new AudioFileOption(file, tokens);

                newOption.ScoreTrackNumberTrackPoints(SearchMethodType.Backwards);

                pass1.AddAudioFileOption(newOption);
            }

            pass1.KeepBetterOptions();

            return(pass1);
        }
        private static AudioFileOptions ArtistAlbum_Pass1(AudioLibrary audioLibrary, TokensCollection tokens)
        {
            //Forwards Search
            AudioFileOptions pass1 = new AudioFileOptions();

            foreach (AudioLibraryFile file in audioLibrary.GetAudioLibraryFiles)
            {
                AudioFileOption newOption = new AudioFileOption(file, tokens);

                newOption.ScoreArtistAlbumPoints();

                pass1.AddAudioFileOption(newOption);
            }

            pass1.KeepBetterOptions();

            return(pass1);
        }
        public AODLoadSheetRow(int loadSheetRowNumber, List <string> loadSheetRowCells, AudioEncoderConfig config)
        {
            _LoadSheetRowNumber = loadSheetRowNumber;

            _Airline        = loadSheetRowCells[0];
            _AltCycle       = loadSheetRowCells[1];
            _Artist         = loadSheetRowCells[2];
            _Album          = loadSheetRowCells[3];
            _TrackNumber    = loadSheetRowCells[4];
            _Track          = loadSheetRowCells[5];
            _OutputFilename = loadSheetRowCells[6];
            _AudioType      = loadSheetRowCells[7];
            _ShipTo         = loadSheetRowCells[8];
            _Status         = loadSheetRowCells[9];

            _Config = config;

            _Cycle = _Config.Cycle;

            _AirlineFullName = GetAirlineFullName();

            _OutputFilenameExtension = Path.GetExtension(_OutputFilename).ToLower();

            _DestinationPath = GetDestinationPath();  //Uses loadsheet's cycle (_Cycle) for file output directory

            _Tokens = new TokensCollection(this);

            _OriginalSearchStrategy = _Tokens.SearchStrategy;

            if (CycleValidator.Validate4DigitCycle(_AltCycle) && _AltCycle != _Cycle)
            {
                //If altCycle was detected in album text, it is overwritten again with the value from the "Alt. Cycle" loadsheet column
                _Tokens.CycleTokens.SetAlternativeCycle(_AltCycle, _Airline);
            }

            _SearchCycle = _Tokens.CycleTokens.FullToken;

            if (NormalizeText(_ShipTo).Contains(Globals.ROCKWELL))
            {
                _LoadSheetRowHash = NormalizeText(_SearchCycle + _Airline + _Artist + _Album + _TrackNumber + _Track + _AudioType + _ShipTo);
            }
            else
            {
                _LoadSheetRowHash = NormalizeText(_SearchCycle + _Airline + _Artist + _Album + _TrackNumber + _Track + _AudioType);
            }

            _AirlineAudioTypeHash = NormalizeText(_Airline + _AudioType);

            _AirlineAlbumAudioTypeHash = NormalizeText(_Airline + _Album + _AudioType);

            _TrackNumberTrackHash = NormalizeText(_TrackNumber + _Track);

            _CharCountArtistAlbumTrackNumberTrack = _Artist.Length
                                                    + _Album.Length
                                                    + _TrackNumber.Length
                                                    + _Track.Length;

            _IsApproved = false;

            _EncodingResult             = Globals.Failed;
            _EncodedFileDurationPretty  = Globals.Failed;
            _EncodedFileDurationSeconds = 0;

            _IsQuickSearchActive = false;

            _QuickSearchNotePastLSR     = "None";
            _QuickSearchNotePreviousLSR = "None";

            _SearchCollection = null;

            _SuggestedAudioFile = null;

            _IsSuggestedAudioFileAssigned = false;
        }
        private static AudioFileSearchCollection BackwardsSearch(AudioFileSearchCollection searchCollection, AudioLibrary audioLibrary, TokensCollection tokens)
        {
            //Backwards Search priority:  Track  --->  Artist/Album

            AudioFileOptions pass1 = Track_Pass1(audioLibrary, tokens);

            AudioFileOptions pass2 = ArtistAlbum_Pass2(pass1);

            pass2.FinishAllOptions();

            AudioFileOptions finalPass = pass2.Clone();

            finalPass.TieBreakAudioFileOptions(SearchMethodType.Backwards);

            searchCollection.AssignBackwardsSearchPasses(pass1, pass2, finalPass);

            return(searchCollection);
        }