522 lines
22 KiB
C#
522 lines
22 KiB
C#
using System.Text.Json;
|
|
using PlotLine.Data;
|
|
using PlotLine.Models;
|
|
using PlotLine.ViewModels;
|
|
|
|
namespace PlotLine.Services;
|
|
|
|
public interface IStoryIntelligenceCharacterImportService
|
|
{
|
|
Task<StoryIntelligenceCharacterReviewViewModel> BuildReviewAsync(OnboardingStoryIntelligenceBatch batch);
|
|
Task<StoryIntelligenceImportCommitResult> ImportAsync(OnboardingStoryIntelligenceBatch batch, StoryIntelligenceCharacterImportForm form);
|
|
}
|
|
|
|
public sealed class StoryIntelligenceCharacterImportService(
|
|
IStoryIntelligenceResultRepository runs,
|
|
ICharacterRepository characters,
|
|
ISceneRepository scenes,
|
|
IStoryIntelligencePipelineStateService pipelineState,
|
|
ILogger<StoryIntelligenceCharacterImportService> logger) : IStoryIntelligenceCharacterImportService
|
|
{
|
|
private static readonly JsonSerializerOptions JsonOptions = new()
|
|
{
|
|
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
|
|
PropertyNameCaseInsensitive = true
|
|
};
|
|
|
|
private static readonly HashSet<string> IgnoredNames = CreateSet("narrator", "unknown");
|
|
|
|
private static readonly HashSet<string> GenericPeople = CreateSet(
|
|
"man", "woman", "boy", "girl", "child", "children", "person", "people", "doctor", "nurse",
|
|
"police officer", "driver", "receptionist", "attendant", "guard", "security guard", "waiter", "waitress",
|
|
"clerk", "shopkeeper", "cashier", "crowd", "family", "group", "small group");
|
|
|
|
public async Task<StoryIntelligenceCharacterReviewViewModel> BuildReviewAsync(OnboardingStoryIntelligenceBatch batch)
|
|
{
|
|
var data = await BuildCandidateDataAsync(batch);
|
|
var decidedKeys = batch.CharacterDecisions.Select(decision => decision.Key).ToHashSet(StringComparer.OrdinalIgnoreCase);
|
|
var visibleCandidates = data.Candidates.Where(candidate => !decidedKeys.Contains(candidate.Key)).ToList();
|
|
return new StoryIntelligenceCharacterReviewViewModel
|
|
{
|
|
HasCommittedScenes = data.HasCommittedScenes,
|
|
CanImport = visibleCandidates.Count > 0,
|
|
AlreadyLinkedCount = data.AlreadyLinkedCount,
|
|
IsComplete = data.HasCommittedScenes && visibleCandidates.Count == 0,
|
|
Candidates = visibleCandidates.Select(candidate => new StoryIntelligenceCharacterReviewCandidateViewModel
|
|
{
|
|
Key = candidate.Key,
|
|
CharacterName = candidate.DisplayName,
|
|
ImportName = candidate.DisplayName,
|
|
AppearsInScenes = candidate.PresentAppearances.Concat(candidate.MentionedOnlyAppearances).Select(appearance => appearance.SceneID).Distinct().Count(),
|
|
Confidence = ConfidenceBand(candidate.Confidence),
|
|
PossibleAliases = candidate.Aliases.OrderBy(value => value).ToList(),
|
|
ExampleFirstAppearance = candidate.FirstAppearanceNote,
|
|
ExistingCharacterID = candidate.ExistingCharacterID,
|
|
ExistingCharacterName = candidate.ExistingCharacterName
|
|
}).ToList()
|
|
};
|
|
}
|
|
|
|
public async Task<StoryIntelligenceImportCommitResult> ImportAsync(OnboardingStoryIntelligenceBatch batch, StoryIntelligenceCharacterImportForm form)
|
|
{
|
|
var data = await BuildCandidateDataAsync(batch);
|
|
if (!data.HasCommittedScenes)
|
|
{
|
|
return new StoryIntelligenceImportCommitResult { Success = false, Message = "Create scenes before importing characters." };
|
|
}
|
|
|
|
var choices = form.Characters
|
|
.Where(choice => !string.IsNullOrWhiteSpace(choice.Key))
|
|
.ToDictionary(choice => choice.Key, choice => choice, StringComparer.OrdinalIgnoreCase);
|
|
if (choices.Count == 0)
|
|
{
|
|
return new StoryIntelligenceImportCommitResult { Success = false, Message = "Choose at least one character to create, link or ignore." };
|
|
}
|
|
|
|
var existingIndex = await BuildCharacterIndexAsync(batch.ProjectID);
|
|
var lookupData = await characters.GetLookupsAsync(batch.ProjectID);
|
|
var roleTypes = lookupData.RoleTypes;
|
|
var presenceTypes = lookupData.PresenceTypes;
|
|
var created = 0;
|
|
var linkedExisting = 0;
|
|
var ignored = 0;
|
|
var linkedAppearances = 0;
|
|
var povLinks = 0;
|
|
var resolvedCharacters = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
foreach (var candidate in data.Candidates)
|
|
{
|
|
if (!choices.TryGetValue(candidate.Key, out var choice))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (string.Equals(choice.Action, StoryIntelligenceCharacterImportActions.Ignore, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
ignored++;
|
|
AddDecision(batch, candidate.Key, StoryIntelligenceCharacterImportActions.Ignore, candidate.DisplayName, null, false);
|
|
continue;
|
|
}
|
|
|
|
var requestedName = Clean(choice.ImportName);
|
|
var importName = string.IsNullOrWhiteSpace(requestedName) ? candidate.DisplayName : requestedName;
|
|
var forceCreateSeparate = string.Equals(choice.Action, StoryIntelligenceCharacterImportActions.CreateSeparate, StringComparison.OrdinalIgnoreCase);
|
|
var matchedExistingId = forceCreateSeparate
|
|
? null
|
|
: candidate.ExistingCharacterID
|
|
?? existingIndex.Find(importName)?.CharacterID
|
|
?? existingIndex.Find(candidate.DisplayName)?.CharacterID;
|
|
var characterId = matchedExistingId;
|
|
|
|
if (!characterId.HasValue)
|
|
{
|
|
characterId = await characters.SaveCharacterAsync(new Character
|
|
{
|
|
ProjectID = batch.ProjectID,
|
|
CharacterName = importName,
|
|
ShortName = FirstName(importName),
|
|
DefaultDescription = candidate.Description
|
|
});
|
|
created++;
|
|
}
|
|
else
|
|
{
|
|
linkedExisting++;
|
|
}
|
|
|
|
AddResolvedName(resolvedCharacters, candidate.DisplayName, characterId.Value);
|
|
AddResolvedName(resolvedCharacters, importName, characterId.Value);
|
|
foreach (var alias in candidate.Aliases)
|
|
{
|
|
AddResolvedName(resolvedCharacters, alias, characterId.Value);
|
|
await TryAddAliasAsync(characterId.Value, alias, importName);
|
|
}
|
|
|
|
foreach (var appearance in candidate.PresentAppearances)
|
|
{
|
|
await characters.SaveSceneCharacterAsync(new SceneCharacter
|
|
{
|
|
SceneID = appearance.SceneID,
|
|
CharacterID = characterId.Value,
|
|
RoleInSceneTypeID = MatchRole(roleTypes, appearance.RoleInScene),
|
|
PresenceTypeID = MatchPresence(presenceTypes, appearance.MentionedOnly),
|
|
AppearanceNotes = appearance.Notes
|
|
});
|
|
linkedAppearances++;
|
|
}
|
|
|
|
AddDecision(batch, candidate.Key, choice.Action, importName, characterId.Value, true);
|
|
}
|
|
|
|
foreach (var scene in data.SceneAnalyses)
|
|
{
|
|
var povName = Clean(scene.Parsed.PointOfView?.CharacterName);
|
|
if (string.IsNullOrWhiteSpace(povName) || !resolvedCharacters.TryGetValue(povName, out var characterId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
await scenes.UpdatePovCharacterAsync(scene.SceneID, characterId);
|
|
povLinks++;
|
|
}
|
|
|
|
batch.CharacterStageComplete = true;
|
|
batch.LastCharacterImportResult = new StoryIntelligenceCharacterImportBatchResult
|
|
{
|
|
CharactersCreated = created,
|
|
CharactersLinked = linkedExisting,
|
|
CharactersIgnored = ignored,
|
|
PovLinksResolved = povLinks,
|
|
ScenePeoplePanelsUpdated = linkedAppearances
|
|
};
|
|
await pipelineState.RecordCharacterImportAsync(batch.ProjectID, batch.BookID);
|
|
|
|
logger.LogInformation(
|
|
"Imported Story Intelligence characters for batch {BatchID}. Created={Created} LinkedExisting={LinkedExisting} Ignored={Ignored} LinkedAppearances={LinkedAppearances} PovLinks={PovLinks}",
|
|
batch.BatchID,
|
|
created,
|
|
linkedExisting,
|
|
ignored,
|
|
linkedAppearances,
|
|
povLinks);
|
|
|
|
return new StoryIntelligenceImportCommitResult
|
|
{
|
|
Success = true,
|
|
ScenesCreated = linkedAppearances,
|
|
Message = $"Characters imported. {created:N0} created, {linkedExisting:N0} linked, {ignored:N0} ignored, {linkedAppearances:N0} scene appearance(s) updated, {povLinks:N0} POV link(s) resolved."
|
|
};
|
|
}
|
|
|
|
private static void AddDecision(OnboardingStoryIntelligenceBatch batch, string key, string action, string? characterName, int? characterId, bool createdOrLinked)
|
|
{
|
|
batch.CharacterDecisions.RemoveAll(decision => string.Equals(decision.Key, key, StringComparison.OrdinalIgnoreCase));
|
|
batch.CharacterDecisions.Add(new OnboardingStoryIntelligenceCharacterDecision
|
|
{
|
|
Key = key,
|
|
Action = action,
|
|
CharacterName = characterName,
|
|
CharacterID = characterId,
|
|
CreatedOrLinked = createdOrLinked
|
|
});
|
|
}
|
|
|
|
private async Task<CharacterCandidateData> BuildCandidateDataAsync(OnboardingStoryIntelligenceBatch batch)
|
|
{
|
|
var existingIndex = await BuildCharacterIndexAsync(batch.ProjectID);
|
|
var groups = new Dictionary<string, CharacterCandidate>(StringComparer.OrdinalIgnoreCase);
|
|
var sceneAnalyses = new List<ImportedSceneAnalysis>();
|
|
var alreadyLinked = 0;
|
|
var hasCommittedScenes = false;
|
|
|
|
foreach (var item in batch.Items)
|
|
{
|
|
var commit = await runs.GetImportCommitAsync(item.RunID);
|
|
if (commit is null || !string.Equals(commit.Status, StoryIntelligenceImportCommitStatuses.Completed, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
hasCommittedScenes = true;
|
|
var importedScenes = (await scenes.ListByChapterAsync(item.ChapterID))
|
|
.Where(scene => scene.ImportRunID == item.RunID)
|
|
.ToList();
|
|
var importedByRange = importedScenes
|
|
.Where(scene => scene.SourceStartParagraph.HasValue && scene.SourceEndParagraph.HasValue)
|
|
.ToDictionary(scene => $"{scene.SourceStartParagraph}-{scene.SourceEndParagraph}", scene => scene, StringComparer.OrdinalIgnoreCase);
|
|
var importedByNumber = importedScenes.ToDictionary(scene => Convert.ToInt32(scene.SceneNumber), scene => scene);
|
|
var sceneResults = await runs.ListSceneResultsAsync(item.RunID);
|
|
|
|
foreach (var sceneResult in sceneResults)
|
|
{
|
|
var parsed = TryReadScene(sceneResult);
|
|
if (parsed is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var importedScene = ResolveImportedScene(sceneResult, importedByRange, importedByNumber);
|
|
if (importedScene is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
sceneAnalyses.Add(new ImportedSceneAnalysis(importedScene.SceneID, parsed));
|
|
var existingAppearances = await characters.ListSceneCharactersAsync(importedScene.SceneID);
|
|
alreadyLinked += existingAppearances.Count;
|
|
|
|
foreach (var character in parsed.Characters ?? [])
|
|
{
|
|
AddMention(groups, existingIndex, importedScene, parsed, character, existingAppearances);
|
|
}
|
|
}
|
|
}
|
|
|
|
var candidates = groups.Values
|
|
.Where(candidate => candidate.PresentAppearances.Count > 0 || candidate.MentionedOnlyAppearances.Count > 0)
|
|
.Where(candidate => candidate.PresentAppearances.Any(appearance => !appearance.AlreadyLinked))
|
|
.OrderByDescending(candidate => candidate.PresentAppearances.Select(appearance => appearance.SceneID).Distinct().Count())
|
|
.ThenBy(candidate => candidate.DisplayName)
|
|
.ToList();
|
|
|
|
return new CharacterCandidateData(hasCommittedScenes, alreadyLinked, candidates, sceneAnalyses);
|
|
}
|
|
|
|
private static void AddMention(
|
|
Dictionary<string, CharacterCandidate> groups,
|
|
CharacterIndex existingIndex,
|
|
Scene importedScene,
|
|
SceneIntelligenceScene parsed,
|
|
SceneIntelligenceCharacter character,
|
|
IReadOnlyList<SceneCharacter> existingAppearances)
|
|
{
|
|
var name = Clean(character.Name);
|
|
if (string.IsNullOrWhiteSpace(name) || IgnoredNames.Contains(name) || IsGenericPerson(name))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var key = Normalise(name);
|
|
if (!groups.TryGetValue(key, out var candidate))
|
|
{
|
|
var match = existingIndex.Find(name);
|
|
candidate = new CharacterCandidate(key, name, match?.CharacterID, match?.CharacterName);
|
|
groups[key] = candidate;
|
|
}
|
|
|
|
foreach (var alias in character.Aliases ?? [])
|
|
{
|
|
var cleanAlias = Clean(alias);
|
|
if (!string.IsNullOrWhiteSpace(cleanAlias) && !string.Equals(cleanAlias, candidate.DisplayName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
candidate.Aliases.Add(cleanAlias);
|
|
}
|
|
}
|
|
|
|
var notes = Clean(character.Notes);
|
|
if (string.IsNullOrWhiteSpace(notes) && character.Actions?.Count > 0)
|
|
{
|
|
notes = Clean(string.Join("; ", character.Actions));
|
|
}
|
|
|
|
var appearance = new CharacterAppearanceImport(
|
|
importedScene.SceneID,
|
|
importedScene.SceneNumber,
|
|
importedScene.SceneTitle,
|
|
character.RoleInScene,
|
|
character.MentionedOnly == true,
|
|
notes,
|
|
character.Confidence,
|
|
candidate.ExistingCharacterID.HasValue && existingAppearances.Any(appearance => appearance.CharacterID == candidate.ExistingCharacterID.Value));
|
|
if (character.MentionedOnly == true)
|
|
{
|
|
candidate.MentionedOnlyAppearances.Add(appearance);
|
|
}
|
|
else
|
|
{
|
|
candidate.PresentAppearances.Add(appearance);
|
|
}
|
|
|
|
candidate.Confidence = Max(candidate.Confidence, character.Confidence);
|
|
candidate.Description ??= notes;
|
|
candidate.FirstAppearanceNote ??= BuildFirstAppearance(importedScene, parsed, character);
|
|
}
|
|
|
|
private async Task<CharacterIndex> BuildCharacterIndexAsync(int projectId)
|
|
{
|
|
var index = new CharacterIndex();
|
|
foreach (var character in await characters.ListCharactersAsync(projectId))
|
|
{
|
|
index.Add(character.CharacterName, character.CharacterID, character.CharacterName);
|
|
index.Add(character.ShortName, character.CharacterID, character.CharacterName);
|
|
foreach (var alias in await characters.ListAliasesAsync(character.CharacterID))
|
|
{
|
|
index.Add(alias.Alias, character.CharacterID, character.CharacterName);
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
private async Task TryAddAliasAsync(int characterId, string alias, string primaryName)
|
|
{
|
|
var cleanAlias = Clean(alias);
|
|
if (string.IsNullOrWhiteSpace(cleanAlias) || string.Equals(cleanAlias, primaryName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var existingAliases = await characters.ListAliasesAsync(characterId);
|
|
if (existingAliases.Any(item => string.Equals(Clean(item.Alias), cleanAlias, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
await characters.AddAliasAsync(characterId, cleanAlias, null);
|
|
}
|
|
|
|
private static Scene? ResolveImportedScene(
|
|
StoryIntelligenceSavedSceneResult sceneResult,
|
|
IReadOnlyDictionary<string, Scene> byRange,
|
|
IReadOnlyDictionary<int, Scene> byNumber)
|
|
{
|
|
if (sceneResult.StartParagraph.HasValue
|
|
&& sceneResult.EndParagraph.HasValue
|
|
&& byRange.TryGetValue($"{sceneResult.StartParagraph}-{sceneResult.EndParagraph}", out var rangeMatch))
|
|
{
|
|
return rangeMatch;
|
|
}
|
|
|
|
return byNumber.TryGetValue(sceneResult.TemporarySceneNumber, out var numberMatch) ? numberMatch : null;
|
|
}
|
|
|
|
private static SceneIntelligenceScene? TryReadScene(StoryIntelligenceSavedSceneResult result)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(result.ParsedJson))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
try
|
|
{
|
|
var direct = JsonSerializer.Deserialize<SceneIntelligenceScene>(result.ParsedJson, JsonOptions);
|
|
if (!string.IsNullOrWhiteSpace(direct?.SchemaVersion))
|
|
{
|
|
return direct;
|
|
}
|
|
|
|
using var document = JsonDocument.Parse(result.ParsedJson);
|
|
if (document.RootElement.TryGetProperty("parsedScene", out var parsedScene))
|
|
{
|
|
return parsedScene.Deserialize<SceneIntelligenceScene>(JsonOptions);
|
|
}
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static int? MatchRole(IReadOnlyList<CharacterRoleInSceneType> roleTypes, string? role)
|
|
{
|
|
var value = Clean(role);
|
|
if (string.IsNullOrWhiteSpace(value))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return roleTypes.FirstOrDefault(type =>
|
|
value.Contains(type.TypeName, StringComparison.OrdinalIgnoreCase)
|
|
|| type.TypeName.Contains(value, StringComparison.OrdinalIgnoreCase))?.CharacterRoleInSceneTypeID;
|
|
}
|
|
|
|
private static int? MatchPresence(IReadOnlyList<PresenceType> presenceTypes, bool mentionedOnly)
|
|
{
|
|
var preferred = mentionedOnly ? "Mentioned" : "Present";
|
|
return presenceTypes.FirstOrDefault(type => type.TypeName.Contains(preferred, StringComparison.OrdinalIgnoreCase))?.PresenceTypeID;
|
|
}
|
|
|
|
private static void AddResolvedName(Dictionary<string, int> map, string name, int characterId)
|
|
{
|
|
var clean = Clean(name);
|
|
if (!string.IsNullOrWhiteSpace(clean))
|
|
{
|
|
map[clean] = characterId;
|
|
}
|
|
}
|
|
|
|
private static string? BuildFirstAppearance(Scene scene, SceneIntelligenceScene parsed, SceneIntelligenceCharacter character)
|
|
{
|
|
var note = Clean(character.Notes);
|
|
if (!string.IsNullOrWhiteSpace(note))
|
|
{
|
|
return $"Scene {scene.SceneNumber:g}: {note}";
|
|
}
|
|
|
|
var summary = Clean(parsed.Summary?.Short);
|
|
return string.IsNullOrWhiteSpace(summary) ? $"Scene {scene.SceneNumber:g}: {scene.SceneTitle}" : $"Scene {scene.SceneNumber:g}: {summary}";
|
|
}
|
|
|
|
private static decimal? Max(decimal? current, decimal? next)
|
|
=> current.HasValue && next.HasValue ? Math.Max(current.Value, next.Value) : current ?? next;
|
|
|
|
private static string ConfidenceBand(decimal? confidence)
|
|
=> confidence switch
|
|
{
|
|
>= 0.75m => "High",
|
|
>= 0.45m => "Medium",
|
|
null => "Unknown",
|
|
_ => "Low"
|
|
};
|
|
|
|
private static string? FirstName(string name)
|
|
{
|
|
var parts = Clean(name).Split(' ', StringSplitOptions.RemoveEmptyEntries);
|
|
return parts.Length > 1 ? parts[0] : null;
|
|
}
|
|
|
|
private static bool IsGenericPerson(string name)
|
|
=> GenericPeople.Contains(name) || GenericPeople.Contains(Normalise(name));
|
|
|
|
private static string Normalise(string? value)
|
|
=> Clean(value).ToLowerInvariant();
|
|
|
|
private static string Clean(string? value)
|
|
=> string.Join(' ', (value ?? string.Empty).Trim().Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
|
|
|
|
private static HashSet<string> CreateSet(params string[] values)
|
|
=> values.Select(Normalise).ToHashSet(StringComparer.OrdinalIgnoreCase);
|
|
|
|
private sealed class CharacterIndex
|
|
{
|
|
private readonly Dictionary<string, CharacterMatch> byName = new(StringComparer.OrdinalIgnoreCase);
|
|
|
|
public void Add(string? name, int characterId, string characterName)
|
|
{
|
|
var key = Normalise(name);
|
|
if (!string.IsNullOrWhiteSpace(key))
|
|
{
|
|
byName.TryAdd(key, new CharacterMatch(characterId, characterName));
|
|
}
|
|
}
|
|
|
|
public CharacterMatch? Find(string name)
|
|
=> byName.TryGetValue(Normalise(name), out var match) ? match : null;
|
|
}
|
|
|
|
private sealed record CharacterMatch(int CharacterID, string CharacterName);
|
|
|
|
private sealed class CharacterCandidate(string key, string displayName, int? existingCharacterId, string? existingCharacterName)
|
|
{
|
|
public string Key { get; } = key;
|
|
public string DisplayName { get; } = displayName;
|
|
public int? ExistingCharacterID { get; } = existingCharacterId;
|
|
public string? ExistingCharacterName { get; } = existingCharacterName;
|
|
public HashSet<string> Aliases { get; } = new(StringComparer.OrdinalIgnoreCase);
|
|
public List<CharacterAppearanceImport> PresentAppearances { get; } = [];
|
|
public List<CharacterAppearanceImport> MentionedOnlyAppearances { get; } = [];
|
|
public decimal? Confidence { get; set; }
|
|
public string? Description { get; set; }
|
|
public string? FirstAppearanceNote { get; set; }
|
|
}
|
|
|
|
private sealed record CharacterAppearanceImport(
|
|
int SceneID,
|
|
decimal SceneNumber,
|
|
string SceneTitle,
|
|
string? RoleInScene,
|
|
bool MentionedOnly,
|
|
string? Notes,
|
|
decimal? Confidence,
|
|
bool AlreadyLinked);
|
|
|
|
private sealed record ImportedSceneAnalysis(int SceneID, SceneIntelligenceScene Parsed);
|
|
|
|
private sealed record CharacterCandidateData(
|
|
bool HasCommittedScenes,
|
|
int AlreadyLinkedCount,
|
|
IReadOnlyList<CharacterCandidate> Candidates,
|
|
IReadOnlyList<ImportedSceneAnalysis> SceneAnalyses);
|
|
}
|