code guessing, round #72 (completed)

Symbol,Place,Method,Voicing
m̥,bilabial,nasal,
m,bilabial,nasal,voiced
ɱ,labiodental,nasal,voiced
n̼,linguolabial,nasal,voiced
n̥,alveolar,nasal,
n,alveolar,nasal,voiced
ɳ̊,retroflex,nasal,
ɳ,retroflex,nasal,voiced
ɲ̊,palatal,nasal,
ɲ,palatal,nasal,voiced
ŋ̊,velar,nasal,
ŋ,velar,nasal,voiced
ɴ,uvular,nasal,voiced
p,bilabial,plosive,
b,bilabial,plosive,voiced
p̪,labiodental,plosive,
b̪,labiodental,plosive,voiced
t̼,linguolabial,plosive,
d̼,linguolabial,plosive,voiced
t,alveolar,plosive,
d,alveolar,plosive,voiced
ʈ,retroflex,plosive,
ɖ,retroflex,plosive,voiced
c,palatal,plosive,
ɟ,palatal,plosive,voiced
k,velar,plosive,
ɡ,velar,plosive,voiced
q,uvular,plosive,
ɢ,uvular,plosive,voiced
ʡ,epiglottal,plosive,
ʔ,glottal,stop,
s,alveolar,fricative,
z,alveolar,fricative,voiced
ʃ,postalveolar,fricative,
ʒ,postalveolar,fricative,voiced
ʂ,retroflex,fricative,
ʐ,retroflex,fricative,voiced
ɕ,alveolo-palatal,fricative,
ʑ,alveolo-palatal,fricative,voiced
ɸ,bilabial,fricative,
β,bilabial,fricative,voiced
f,labiodental,fricative,
v,labiodental,fricative,voiced
θ̼,linguolabial,fricative,
ð̼,linguolabial,fricative,voiced
θ,dental,fricative,
ð,dental,fricative,voiced
θ̠,alveolar,non-sibilant fricative,
ð̠,alveolar,non-sibilant fricative,voiced
ɹ̠̊˔,postalveolar,non-sibilant fricative,
ɹ̠˔,postalveolar,non-sibilant fricative,voiced
ɻ̊˔,retroflex,non-sibilant fricative,
ɻ˔,retroflex,non-sibilant fricative,voiced
ç,palatal,fricative,
ʝ,palatal,fricative,voiced
x,velar,fricative,
ɣ,velar,fricative,voiced
χ,uvular,fricative,
ʁ,uvular,fricative,voiced
ħ,pharyngeal,fricative,
ʕ,pharyngeal,fricative,voiced
h,glottal,fricative,
ɦ,glottal,fricative,voiced
ʋ,labiodental,approximant,voiced
ɹ,alveolar,approximant,voiced
ɻ,retroflex,approximant,voiced
j,palatal,approximant,voiced
ɰ,velar,approximant,voiced
ʔ̞,creaky-glottal,approximant,
ⱱ̟,bilabial,flap,voiced
ⱱ,labiodental,flap,voiced
ɾ̼,linguolabial,tap,voiced
ɾ̥,alveolar,tap,
ɾ,dental,and alveolar taps and flaps,voiced
ɽ̊,retroflex,flap,
ɽ,retroflex,flap,voiced
ɢ̆,uvular,tap and flap,voiced
ʡ̆,epiglottal,tap,voiced
ʙ̥,bilabial,trill,
ʙ,bilabial,trill,voiced
r̥,alveolar,trill,
r,alveolar,trill,voiced
ɽ̊r̥,retroflex,trill,
ɽr,retroflex,trill,voiced
ʀ̥,uvular,trill,
ʀ,uvular,trill,voiced
ʜ,epiglottal,trill,
ʢ,epiglottal,trill,voiced
ɬ,alveolar,lateral fricative,
ɮ,alveolar,lateral fricative,voiced
ꞎ,retroflex,lateral fricative,
ɭ˔,retroflex,lateral fricative,voiced
𝼆,palatal,lateral fricative,
ʎ̝,palatal,lateral fricative,voiced
𝼄,velar,lateral fricative,
ʟ̝,velar,lateral fricative,voiced
l,alveolar,lateral approximant,voiced
ɭ,retroflex,lateral approximant,voiced
ʎ,palatal,lateral approximant,voiced
ʟ,velar,lateral approximant,voiced
ʟ̠,uvular,lateral approximant,voiced
ɺ̥,alveolar,lateral flap,
ɺ,alveolar,lateral flap,voiced
𝼈̥,retroflex,lateral flap,
𝼈,retroflex,lateral flap,voiced
ʎ̆,palatal,lateral flap,voiced
ʟ̆,velar,lateral tap,voiced

Symbol,Height,Backness,Roundedness
i,close,front,
y,close,front,rounded
ɨ,close,central,
ʉ,close,central,rounded
ɯ,close,back,
u,close,back,rounded
ɪ,near-close,near-front,
ʏ,near-close,near-front,rounded
ʊ,near-close,near-back,rounded
e,close-mid,front,
ø,close-mid,front,rounded
ɘ,close-mid,central,
ɵ,close-mid,central,rounded
ɤ,close-mid,back,
o,close-mid,back,rounded
e̞,mid,front,
ø̞,mid,front,rounded
ə,mid,central,
ɤ̞,mid,back,
o̞,mid,back,rounded
ɛ,open-mid,front,
œ,open-mid,front,rounded
ɜ,open-mid,central,
ɞ,open-mid,central,rounded
ʌ,open-mid,back,
ɔ,open-mid,back,rounded
æ,near-open,front,
ɐ,near-open,central,
a,open,front,
ɶ,open,front,rounded
ä,open,central,
ɑ,open,back,
ɒ,open,back,rounded

using System.Diagnostics.CodeAnalysis;
using ReactiveUI;

namespace Baum.AvaloniaApp.Models;

public class LanguageModel : ReactiveObject
{
    public LanguageModel(string? name, int? parentId = null, string soundChange = "")
        => (_name, _parentId, _soundChange) = (name, parentId, soundChange);

    public int Id { get; set; }

    string? _name;
    public string? Name { get => _name; set => this.RaiseAndSetIfChanged(ref _name, value); }

    int? _parentId;
    public int? ParentId { get => _parentId; set => this.RaiseAndSetIfChanged(ref _parentId, value); }

    string _soundChange;
    public string SoundChange { get => _soundChange; set => this.RaiseAndSetIfChanged(ref _soundChange, value); }
}

using ReactiveUI;

namespace Baum.AvaloniaApp.Models;

public class WordModel : ReactiveObject
{
    public WordModel(string name, string ipa)
        => (_name, _ipa) = (name, ipa);

    public required bool Transient { get; set; }
    public int Id { get; set; }
    public int? AncestorId { get; set; }
    public required int LanguageId { get; set; }

    string _name;
    public string Name { get => _name; set => this.RaiseAndSetIfChanged(ref _name, value); }

    string _ipa;
    public string IPA { get => _ipa; set => this.RaiseAndSetIfChanged(ref _ipa, value); }
}

using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

using Baum.Phonology;
using Baum.AvaloniaApp.Models;

namespace Baum.AvaloniaApp.Services;

public interface IProjectDatabase
{
    bool HasMigrations();
    Task MigrateAsync();

    void SaveToFile(FileInfo fileInfo);

    Task AddAsync(LanguageModel language);
    Task UpdateAsync(LanguageModel language);
    Task<IEnumerable<LanguageModel>> GetLanguagesAsync();
    Task<IEnumerable<LanguageModel>> GetChildrenAsync(int languageId);

    Task<WordModel> AddAsync(WordModel word);
    Task UpdateAsync(WordModel word);
    Task<IEnumerable<WordModel>> GetWordsAsync(int languageId, PhonologyData data);
    Task<IEnumerable<WordModel>> GetAncestryAsync(WordModel word, PhonologyData data);
}

using System.IO;

namespace Baum.AvaloniaApp.Services;

public interface IProjectDatabaseFactory
{
    IProjectDatabase Create(FileInfo fileInfo);
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;

using Baum.Phonology;
using Baum.Data;
using Baum.AvaloniaApp.Models;

namespace Baum.AvaloniaApp.Services;

class ProjectDatabase : IProjectDatabase
{
    FileInfo File { get; }

    public ProjectDatabase(FileInfo fileInfo) => File = fileInfo;

    public async Task AddAsync(LanguageModel languageModel)
    {
        using var context = new ProjectContext(File);

        await context.Languages.AddAsync(new Language
        {
            Name = languageModel.Name,
            ParentId = languageModel.ParentId,
            SoundChange = languageModel.SoundChange,
        });

        await context.SaveChangesAsync();
    }

    public async Task UpdateAsync(LanguageModel languageModel)
    {
        using var context = new ProjectContext(File);

        var language = await context.Languages.FindAsync(languageModel.Id);
        if (language == null) throw new InvalidOperationException("No language found in database");

        language.Name = languageModel.Name;
        language.SoundChange = languageModel.SoundChange;

        await context.SaveChangesAsync();
    }

    public async Task<IEnumerable<LanguageModel>> GetChildrenAsync(int languageId)
    {
        using var context = new ProjectContext(File);

        var entity = await context.Languages.FindAsync(languageId);
        if (entity == null) throw new InvalidOperationException();

        return await (
            from language in context.Languages
            where language.ParentId == languageId
            select new LanguageModel(
                language.Name,
                language.ParentId,
                language.SoundChange) { Id = language.Id }).ToArrayAsync();
    }

    public async Task<IEnumerable<LanguageModel>> GetLanguagesAsync()
    {
        using var context = new ProjectContext(File);

        return await context.Languages
            .Select(l => new LanguageModel(l.Name,l.ParentId,l.SoundChange) { Id = l.Id })
            .ToArrayAsync();
    }

    async Task<WordModel> GetWordAsync(int wordId)
    {
        using var context = new ProjectContext(File);

        var word = await context.Words.FindAsync(wordId);
        if (word == null) throw new InvalidOperationException("Word doesn't exist");

        return new WordModel(word.Name, word.IPA)
        {
            Transient = false,
            Id = word.Id,
            AncestorId = word.AncestorId,
            LanguageId = word.LanguageId,
        };
    }


    public async Task<IEnumerable<WordModel>> GetWordsAsync(int languageId, PhonologyData data)
    {
        using var context = new ProjectContext(File);

        var language = await context.Languages.FindAsync(languageId);
        if (language == null) throw new InvalidOperationException("No language found in database");

        List<WordModel> words = new();

        await foreach (var word in context.Entry(language).Collection(l => l.Words).Query().AsAsyncEnumerable())
        {
            words.Add(new WordModel(word.Name, word.IPA)
            {
                Transient = false,
                Id = word.Id,
                AncestorId = word.AncestorId,
                LanguageId = word.LanguageId,
            });
        }

        if (language.ParentId != null)
        {
            var parentWords = await GetWordsAsync((int)language.ParentId, data);
            foreach (var parentWord in parentWords)
            {
                SoundChange.TryApply(parentWord.IPA, language.SoundChange, data, out var IPA);

                words.Add(new WordModel(parentWord.Name, IPA)
                {
                    Transient = true,
                    LanguageId = languageId,
                    AncestorId = parentWord.Transient ? parentWord.AncestorId : parentWord.Id
                });
            }
        }

        return words;
    }

    public async Task<IEnumerable<WordModel>> GetAncestryAsync(WordModel word, PhonologyData data)
    {
        using var context = new ProjectContext(File);

        if (word.AncestorId == null)
            return Enumerable.Empty<WordModel>();

        var ancester = await context.Words.FindAsync(word.AncestorId);

        if (ancester == null)
            throw new InvalidOperationException("Ancestor does not exist");


        var wordLanguage = await context.Languages.FindAsync(word.LanguageId);
        if (wordLanguage == null)
            throw new InvalidOperationException("Language does not exist");

        await context.Entry(wordLanguage)
            .Reference(l => l.Parent)
            .LoadAsync();

        List<Language> languageChain = new() { };

        while (wordLanguage.Id != ancester.LanguageId)
        {
            if (!string.IsNullOrEmpty(wordLanguage.SoundChange))
                languageChain.Add(wordLanguage);

            await context.Entry(wordLanguage)
                .Reference(l => l.Parent)
                .LoadAsync();

            wordLanguage = wordLanguage.Parent ?? throw new InvalidOperationException("Ancestor is not an ancestor");
        }

        List<WordModel> wordChain = new();
        wordChain.Add(new(ancester.Name, ancester.IPA)
        {
            Transient = false,
            AncestorId = ancester.AncestorId,
            LanguageId = ancester.LanguageId,
        });

        foreach (Language intermediate in Enumerable.Reverse(languageChain))
        {
            var last = wordChain.Last();

            SoundChange.TryApply(last.IPA, intermediate.SoundChange, data, out var next);

            // TODO? Possibly do some error handling or notification here instead of just skipping
            if (last.IPA == next) continue;
            wordChain.Add(new WordModel(last.Name, next)
            {
                Transient = true,
                AncestorId = ancester.Id,
                LanguageId = intermediate.Id
            });
        }

        return wordChain;
    }

    public async Task<WordModel> AddAsync(WordModel word)
    {
        using var context = new ProjectContext(File);

        var language = await context.Languages.FindAsync(word.LanguageId);
        if (language == null) throw new InvalidOperationException("Language doesn't exist");

        var entry = await context.Words.AddAsync(new Word
        {
            Language = language,
            Name = word.Name,
            IPA = word.IPA,
            AncestorId = word.AncestorId,
        });

        await context.SaveChangesAsync();

        word.Id = entry.Entity.Id;
        word.Transient = false;

        return word;
    }

    public async Task UpdateAsync(WordModel wordModel)
    {
        using var context = new ProjectContext(File);

        var word = await context.Words.FindAsync(wordModel.Id);
        if (word == null) throw new InvalidOperationException("Word doesn't exist");

        word.Name = wordModel.Name;
        word.IPA = wordModel.IPA;
        word.AncestorId = wordModel.AncestorId;

        await context.SaveChangesAsync();
    }

    public bool HasMigrations()
    {
        using var context = new ProjectContext(File);
        return context.Database.GetMigrations().Any();
    }

    public async Task MigrateAsync()
    {
        using var context = new ProjectContext(File);
        await context.Database.MigrateAsync();
    }

    public void SaveToFile(FileInfo fileInfo)
    {
        if (fileInfo != File)
        {
            File.CopyTo(fileInfo.FullName, true); // TODO: Prompt user to confirm overwrite
        }
    }
}

using System.IO;

namespace Baum.AvaloniaApp.Services;

class ProjectDatabaseFactory : IProjectDatabaseFactory
{
    public IProjectDatabase Create(FileInfo fileInfo) => new ProjectDatabase(fileInfo);
}

using System.Reactive;
using ReactiveUI;

namespace Baum.AvaloniaApp.ViewModels;

public class HomeViewModel : ViewModelBase
{
    public string OpenButtonText { get; } = "Open File";

    public ReactiveCommand<Unit, Unit> OpenCommand { get; }
    public ReactiveCommand<Unit, Unit> NewCommand { get; }

    public HomeViewModel(ReactiveCommand<Unit, Unit> openCommand, ReactiveCommand<Unit, Unit> newCommand)
    {
        OpenCommand = openCommand;
        NewCommand = newCommand;
    }
}

using System.Collections.ObjectModel;
using System.Linq;
using System.Reactive;
using System.Threading.Tasks;
using ReactiveUI;

using Baum.AvaloniaApp.Models;
using Baum.AvaloniaApp.Services;

namespace Baum.AvaloniaApp.ViewModels;

public class LanguageForestViewModel : ViewModelBase
{
    IProjectDatabase Database { get; }

    ObservableCollection<LanguageTreeViewModel> LanguageTrees { get; set; }

    ReactiveCommand<LanguageModel, Unit> OpenLanguageCommand { get; }
    ReactiveCommand<Unit, Unit> AddLanguageCommand { get; }

    public LanguageForestViewModel(ReactiveCommand<LanguageModel, Unit> openLanguageCommand, IProjectDatabase database)
    {
        Database = database;

        OpenLanguageCommand = openLanguageCommand;
        LanguageTrees = new();
        AddLanguageCommand = ReactiveCommand.CreateFromTask(async () =>
        {
            await database.AddAsync(new LanguageModel("Unnamed Language"));
            await LoadAsync();
        });
    }

    public async Task LoadAsync()
    {
        var trees =
            from tree in await Database.GetLanguagesAsync()
            where tree.ParentId == null
            select tree;

        LanguageTrees.Clear();
        foreach (var tree in trees)
        {
            LanguageTrees.Add(new(tree, OpenLanguageCommand, Database));
        }
    }
}

using System.Collections.ObjectModel;
using System.Reactive;
using System.Threading.Tasks;
using ReactiveUI;

using Baum.AvaloniaApp.Models;
using Baum.AvaloniaApp.Services;

namespace Baum.AvaloniaApp.ViewModels;

public class LanguageTreeViewModel : ViewModelBase
{
    LanguageModel _language;
    LanguageModel Language { get => _language; set => this.RaiseAndSetIfChanged(ref _language, value); }

    ObservableCollection<LanguageTreeViewModel> Children { get; set; }

    string DecendedFromMessage { get; } = "Decended From:";

    ReactiveCommand<LanguageModel, Unit> OpenLanguageCommand { get; }
    ReactiveCommand<Unit, Unit> AddChildCommand { get; }

    IProjectDatabase Database { get; }

    public LanguageTreeViewModel(
        LanguageModel language,
        ReactiveCommand<LanguageModel, Unit> openLanguageCommand,
        IProjectDatabase database)
    {
        _language = language;
        Children = new();

        Database = database;

        OpenLanguageCommand = openLanguageCommand;
        AddChildCommand = ReactiveCommand.CreateFromTask(async () =>
        {
            await Database.AddAsync(new LanguageModel("Unnamed Language", _language.Id) { Id = Language.Id});
            await LoadAsync();
        });
    }

    public async Task LoadAsync()
    {
        Children.Clear();
        foreach (var child in await Database.GetChildrenAsync(Language.Id))
        {
            Children.Add(new(child, OpenLanguageCommand, Database));
        }
    }
}

using System.Collections.ObjectModel;
using System.Reactive;
using System.Reactive.Linq;
using System.Threading.Tasks;
using ReactiveUI;

using Baum.Phonology;

using Baum.AvaloniaApp.Models;
using Baum.AvaloniaApp.Services;

namespace Baum.AvaloniaApp.ViewModels;

public class LanguageViewModel : ViewModelBase
{
    PhonologyData Data { get; set; }
    IProjectDatabase Database { get; set; }

    LanguageModel _languageModel;
    public LanguageModel Language { get => _languageModel; set => this.RaiseAndSetIfChanged(ref _languageModel, value); }

    public ObservableCollection<WordViewModel> Words { get; }

    WordViewModel? _currentWord;
    public WordViewModel? CurrentWord { get => _currentWord; set => this.RaiseAndSetIfChanged(ref _currentWord, value); }

    public ReactiveCommand<Unit, Unit> AddWordCommand { get; }
    public ReactiveCommand<LanguageModel, Unit> SaveCommand { get; }

    public LanguageViewModel(LanguageModel language, IProjectDatabase database, PhonologyData data)
    {
        _languageModel = language;
        Words = new();
        Database = database;
        Data = data;
        AddWordCommand = ReactiveCommand.CreateFromTask(async () =>
        {
            await Database.AddAsync(new WordModel("New Word", "")
            {
                Transient = false,
                LanguageId = Language.Id
            });
            await LoadAsync();
        });

        SaveCommand = ReactiveCommand.CreateFromTask(async (LanguageModel language) =>
        {
            await Database.UpdateAsync(language);
            await LoadAsync();
        });

        this.WhenAnyValue(
            _ => _.Language,
            _ => _.Language.Name,
            _ => _.Language.SoundChange,
            (l, _, _) => l)
            .InvokeCommand(SaveCommand);

        this.WhenAnyValue(_ => _.CurrentWord)
            .IgnoreElements()
            .InvokeCommand(ReactiveCommand.CreateFromTask(_ => LoadAsync()));
    }

    public async Task LoadAsync()
    {
        Words.Clear();
        foreach (var word in await Database.GetWordsAsync(Language.Id, Data))
        {
            Words.Add(new(word, Database, Data));
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Reactive;
using System.Reactive.Linq;
using Avalonia;
using Avalonia.Platform;
using ReactiveUI;

using Baum.AvaloniaApp.Services;

namespace Baum.AvaloniaApp.ViewModels;

public class MainWindowViewModel : ViewModelBase
{
    ViewModelBase _content;
    public ViewModelBase Content { get => _content; set => this.RaiseAndSetIfChanged(ref _content, value); }

    public Interaction<Unit, bool> ConfirmMigrationInteraction { get; }
    public Interaction<Unit, FileInfo?> RequestFileInteraction { get; }
    public Interaction<Unit, FileInfo?> RequestSaveFileInteraction { get; }
    public Interaction<Unit, FileInfo> RequestTemporaryFileInteraction { get; }

    IProjectDatabaseFactory DatabaseFactory { get; }

    public MainWindowViewModel(IProjectDatabaseFactory databaseFactory)
    {
        _content = new HomeViewModel(
            ReactiveCommand.CreateFromTask(OpenFileAsync),
            ReactiveCommand.CreateFromTask(NewFileAsync));

        ConfirmMigrationInteraction = new();
        RequestFileInteraction = new();
        RequestSaveFileInteraction = new();
        RequestTemporaryFileInteraction = new();
        DatabaseFactory = databaseFactory;
    }

    async Task OpenFileAsync()
    {
        var file = await RequestFileInteraction.Handle(Unit.Default);

        if (file != null)
        {
            // TODO: Implement dirty tracking and stuff
            // var tempFile = await RequestTemporaryFileInteraction.Handle(Unit.Default);
            // file.CopyTo(tempFile.FullName, true);
            var tempFile = file;
            var database = await GetDatabase(tempFile);
            if (database != null)
                await OpenAsync(database, file);
        }
    }

    async Task NewFileAsync()
    {
        var file = await RequestTemporaryFileInteraction.Handle(Unit.Default);
        var database = await GetDatabase(file);
        if (database != null)
            await OpenAsync(database, null);
    }

    async Task OpenAsync(IProjectDatabase database, FileInfo? file)
    {
        var assets = AvaloniaLocator.Current.GetService<IAssetLoader>();
        List<Phonology.Sound> sounds = new();
        using (var stream = assets.Open(new Uri("avares://Baum.AvaloniaApp/Assets/ipa-consonants.csv")))
        {
            using var reader = new StreamReader(stream);
            sounds.AddRange(await Phonology.Utils.CsvLoader.LoadAsync(reader));
        }

        using (var stream = assets.Open(new Uri("avares://Baum.AvaloniaApp/Assets/ipa-vowels.csv")))
        {
            using var reader = new StreamReader(stream);
            sounds.AddRange(await Phonology.Utils.CsvLoader.LoadAsync(reader));
        }

        var vm = new ProjectViewModel(
            database,
            file,
            new(sounds));

        vm.RequestSaveFileInteraction.RegisterHandler(
            async i => i.SetOutput(await RequestSaveFileInteraction.Handle(Unit.Default)));

        Content = vm;
    }

    async Task<IProjectDatabase?> GetDatabase(FileInfo file)
    {
        var database = DatabaseFactory.Create(file);
        if (database.HasMigrations())
        {
            if (!await ConfirmMigrationInteraction.Handle(Unit.Default))
                return null;

            await database.MigrateAsync();
        }
        return database;
    }
}

using System.Reactive;
using ReactiveUI;

namespace Baum.AvaloniaApp.ViewModels;

public class MigrationConfirmationWindowViewModel : ViewModelBase
{
    public ReactiveCommand<Unit, bool> ConfirmCommand { get; }
    public ReactiveCommand<Unit, bool> RejectCommand { get; }

    public MigrationConfirmationWindowViewModel()
    {
        ConfirmCommand = ReactiveCommand.Create(() => true);
        RejectCommand = ReactiveCommand.Create(() => false);
    }
}

using System.IO;
using System.Reactive;
using System.Reactive.Linq;
using System.Threading.Tasks;
using ReactiveUI;

using Baum.Phonology;

using Baum.AvaloniaApp.Models;
using Baum.AvaloniaApp.Services;

namespace Baum.AvaloniaApp.ViewModels;

public class ProjectViewModel : ViewModelBase
{
    PhonologyData Data { get; set; }
    IProjectDatabase Database { get; }
    FileInfo? SaveFileInfo { get; set; }

    ViewModelBase? _content;
    public ViewModelBase? Content { get => _content; set => this.RaiseAndSetIfChanged(ref _content, value); }

    public ReactiveCommand<Unit, Unit> OpenLanguageForestCommand { get; }
    public ReactiveCommand<LanguageModel, Unit> OpenLanguageCommand { get; }
    public ReactiveCommand<Unit, Unit> SaveCommand { get; }

    public Interaction<Unit, FileInfo> RequestSaveFileInteraction { get; }

    public ProjectViewModel(IProjectDatabase database, FileInfo? file, PhonologyData data)
    {
        Data = data;
        Database = database;
        SaveFileInfo = file;
        OpenLanguageCommand = ReactiveCommand.Create<LanguageModel>(OpenLanguage);
        OpenLanguageForestCommand = ReactiveCommand.Create(() =>
        {
            Content = new LanguageForestViewModel(OpenLanguageCommand, Database);
        });
        SaveCommand = ReactiveCommand.CreateFromTask(SaveToFile);
        RequestSaveFileInteraction = new();
        Content = new LanguageForestViewModel(OpenLanguageCommand, Database);
    }

    async Task SaveToFile()
    {
        if (SaveFileInfo == null)
        {
            SaveFileInfo = await RequestSaveFileInteraction.Handle(Unit.Default);
        }
        if (SaveFileInfo != null)
        {
            Database.SaveToFile(SaveFileInfo);
        }
    }

    void OpenLanguage(LanguageModel language) => Content = new LanguageViewModel(language, Database, Data);
}

using ReactiveUI;

namespace Baum.AvaloniaApp.ViewModels;

public class ViewModelBase : ReactiveObject
{
}

using System.Collections.ObjectModel;
using System.Reactive;
using System.Reactive.Linq;
using System.Linq;
using ReactiveUI;

using Baum.Phonology;

using Baum.AvaloniaApp.Models;
using Baum.AvaloniaApp.Services;

namespace Baum.AvaloniaApp.ViewModels;

public class WordViewModel : ViewModelBase
{
    IProjectDatabase Database { get; }

    WordModel _wordModel;
    public WordModel Word { get => _wordModel; set => this.RaiseAndSetIfChanged(ref _wordModel, value); }

    public ObservableCollection<WordModel> Ancestry { get; set; }

    ReactiveCommand<WordModel, Unit> SaveCommand { get; }

    public WordViewModel(WordModel word, IProjectDatabase database, PhonologyData data)
    {
        _wordModel = word;
        Ancestry = new();
        Database = database;

        SaveCommand = ReactiveCommand.CreateFromTask(async (WordModel word) =>
        {
            if (word.Transient)
                Word = await Database.AddAsync(word);
            else
                await Database.UpdateAsync(word);
        });

        this.WhenAnyValue(
            _ => _.Word,
            _ => _.Word.Name,
            _ => _.Word.IPA,
            (w, _, _) => w)
            .Skip(1)
            .InvokeCommand(SaveCommand);

        this.WhenAnyValue(_ => _.Word)
            .InvokeCommand(ReactiveCommand.CreateFromTask(async (WordModel word) =>
            {
                Ancestry.Clear();
                foreach (var ancestor in await Database.GetAncestryAsync(word, data))
                {
                    Ancestry.Add(ancestor);
                }
            }));
    }
}