public FansubFile Transform(FansubFile file)
{
var indexOfLastBreak = file.SeriesName.LastIndexOf(' ');
if (indexOfLastBreak == -1)
{
return new FansubFile(file.FansubGroup, string.Empty, file.EpisodeNumber, file.Extension);
}
var newSeriesName = file.SeriesName.Substring(0, indexOfLastBreak);
return new FansubFile(file.FansubGroup, newSeriesName, file.EpisodeNumber, file.Extension);
}
public string Compare(FansubFile file, IEnumerable<string> folders, Strategy.ComparisonStrategy strategy)
{
var justFolderNamesMap = folders.ToDictionary(key => key, value => StringUtilities.GetJustFolderName(value));
var seriesName = file.SeriesName;
foreach (var folder in justFolderNamesMap)
{
var stringsToCompare = strategy.Invoke(seriesName, folder.Value);
var transformedSeriesName = stringsToCompare.Item1;
var transformedFolderName = stringsToCompare.Item2;
if(transformedSeriesName.Equals(transformedFolderName, StringComparison.Ordinal))
{
return folder.Key;
}
}
return null;
}
private static IEnumerable<KeyValuePair<string, double>> CalculateDistances(FansubFile file, IEnumerable<string> folders, Strategy.ComparisonStrategy strategy)
{
var bagOfResults = new ConcurrentDictionary<string, double>();
var justFolders = folders.ToDictionary(key => key, value => StringUtilities.GetJustFolderName(value));
Parallel.ForEach(justFolders, folder =>
{
var projectedStrategy = strategy.Invoke(file.SeriesName, folder.Value);
var seriesName = projectedStrategy.Item1;
var projectedFolderName = projectedStrategy.Item2;
bagOfResults.TryAdd(folder.Key, StringMetricsCalculator.Instance.MeasureSimilarity(seriesName, projectedFolderName));
});
var listResult = bagOfResults.ToList();
listResult.Sort(KeyValuePairComparison);
return listResult;
}
public string Compare(FansubFile file, IEnumerable<string> folders, Strategy.ComparisonStrategy strategy)
{
var distances = CalculateDistances(file, folders, strategy);
if (!distances.Any())
{
return null;
}
var headItem = distances.First();
var comparison = headItem.Value - _smudgeFactor;
var comparisonMagnitude = Math.Abs(comparison);
if (comparison >= 0.0 && comparisonMagnitude >= _epsilon)
{
return headItem.Key;
}
return null;
}
private IList<KeyValuePair<string, double>> MeasureDistances(FansubFile file, Func<string, string, double> metricFunc, IEnumerable<string> knownFolders)
{
var bagOfResults = new ConcurrentDictionary<string, double>();
var seriesName = file.SeriesName;
Parallel.ForEach(knownFolders, folder =>
{
var folderName = GetJustFolderName(folder);
bagOfResults.TryAdd(folder, metricFunc.Invoke(seriesName, folderName));
});
var listResult = bagOfResults.ToList();
listResult.Sort((a, b) =>
{
//We want to sort from largest to smallest, so we reverse the comparison
var result = b.Value - a.Value;
if (result < 0) return -1;
if (result > 0) return 1;
return 0;
});
return listResult;
}
/// <summary>
/// Try to get the folder the <see cref="FansubFile"/> belongs to.
/// </summary>
/// <param name="file">The <see cref="FansubFile"/> you want to submit.</param>
/// <param name="folder">Out parameter where the folder location will be written to.</param>
/// <returns>True if the folder was found. False otherwise.</returns>
public bool TrySubmitFansubFile(FansubFile file, out string folder)
{
folder = default(string);
foreach (FansubFile currentFile in ChompingEnumerable(file))
{
foreach (var transformation in _stageOneTransformations)
{
var transformedFile = transformation.Transform(currentFile);
foreach (var comparator in _comparators)
{
foreach (var strategy in _comparisonStrategies)
{
var result = comparator.Compare(transformedFile, _knownFolders, strategy);
if (result != null)
{
folder = result;
return true;
}
}
}
}
}
return false;
}
public IList<KeyValuePair<string, double>> MeasureStringDistanceIgnoreCase(FansubFile file, IEnumerable<string> knownFolders)
{
return MeasureDistances(file, StringMetricsCalculator.Instance.MeasureSimilarityIgnoreCase, knownFolders);
}
private static IEnumerable<FansubFile> ChompingEnumerable(FansubFile file)
{
FansubFile currentFile = file.DeepCopy();
while (!currentFile.SeriesName.Equals(string.Empty))
{
yield return currentFile;
currentFile = _chompingTransformation.Transform(currentFile);
}
}
public FansubFile Transform(FansubFile file)
{
var nameWithoutPunc = ReplacePunctuationAndSymbolsWithSpaces(file.SeriesName);
return new FansubFile(file.FansubGroup, nameWithoutPunc, file.EpisodeNumber, file.Extension);
}
public FansubFile Transform(FansubFile file)
{
var punctuationRemoved = _punctuationTransformation.Transform(file);
return new FansubFile(file.FansubGroup, NormalizeSpaces(punctuationRemoved.SeriesName), file.EpisodeNumber, file.Extension);
}
public FansubFile Transform(FansubFile file)
{
return file.DeepCopy();
}
