using System;

using System.ComponentModel;

​

// (josar):

// OPTION 3: Marker interface

//

// There is a natural dislike for using marker interfaces, but using one is an option. I think that the primary weakness of this

// approach is that it doesn't scale well. Consider, for example, the possibility that either the enum or the model need to be used 

// in a different union for a different scenario. This would mean that we would need a new marker interface to represent it,

// which could lead us to having something like this:

//

// public partial class UserFunctionCall : IScenario1, IScenario2, IScenario3 { ... }

//

// where all these interfaces are marker interfaces that represent different unions. That being said, I don't think this is a

// concern in this particular case.

public interface IFunctionCall

{

}

​

public partial class UserFunctionCall : IFunctionCall

{

    public string Name { get; set; }

    public UserFunctionCall(string name)

    {

        Name = name;

    }

}

​

public readonly partial struct PresetFunctionCall : IFunctionCall, IEquatable<PresetFunctionCall>

{

    private readonly string _value;

​

    /// <summary> Initializes a new instance of <see cref="PresetFunctionCall"/>. </summary>

    /// <exception cref="ArgumentNullException"> <paramref name="value"/> is null. </exception>

    public PresetFunctionCall(string value)

    {

        _value = value ?? throw new ArgumentNullException(nameof(value));

    }

​

    private const string NoneValue = "none";

    private const string AutoValue = "auto";

​

    /// <summary> Means the model does not call a function, and responds to the end-user. </summary>

    public static PresetFunctionCall None { get; } = new PresetFunctionCall(NoneValue);

    /// <summary> Means the model can pick between an end-user or calling a function. </summary>

    public static PresetFunctionCall Auto { get; } = new PresetFunctionCall(AutoValue);

    /// <summary> Determines if two <see cref="PresetFunctionCall"/> values are the same. </summary>

    public static bool operator ==(PresetFunctionCall left, PresetFunctionCall right) => left.Equals(right);

    /// <summary> Determines if two <see cref="PresetFunctionCall"/> values are not the same. </summary>

    public static bool operator !=(PresetFunctionCall left, PresetFunctionCall right) => !left.Equals(right);

    /// <summary> Converts a string to a <see cref="PresetFunctionCall"/>. </summary>

    public static implicit operator PresetFunctionCall(string value) => new PresetFunctionCall(value);

​

    /// <inheritdoc />

    [EditorBrowsable(EditorBrowsableState.Never)]

    public override bool Equals(object obj) => obj is PresetFunctionCall other && Equals(other);

    /// <inheritdoc />

    public bool Equals(PresetFunctionCall other) => 

        string.Equals(_value, other._value, StringComparison.InvariantCultureIgnoreCase);

​

    /// <inheritdoc />

    [EditorBrowsable(EditorBrowsableState.Never)]

    public override int GetHashCode() => _value?.GetHashCode() ?? 0;

    /// <inheritdoc />

    public override string ToString() => _value;

}

​

public partial class ChatCompletions

{

    public IFunctionCall FunctionCall { get; set; }

    public ChatCompletions(IFunctionCall functionCall)

    {

        FunctionCall = functionCall;

    }

}

​

public class Program

{

    public static void Main()

    {

        ChatCompletions c1 = new ChatCompletions(PresetFunctionCall.Auto);

        ChatCompletions c2 = new ChatCompletions(PresetFunctionCall.None);

        ChatCompletions c3 = new ChatCompletions(new UserFunctionCall("my_function"));

        ChatCompletions c4 = new ChatCompletions(new UserFunctionCall("auto"));

        ChatCompletions c5 = new ChatCompletions(new UserFunctionCall("none"));

        Console.WriteLine(c1.FunctionCall);

        Console.WriteLine(c2.FunctionCall);

        Console.WriteLine(@$"{{ ""name"": ""{((UserFunctionCall)c3.FunctionCall).Name}"" }}");

        Console.WriteLine(@$"{{ ""name"": ""{((UserFunctionCall)c4.FunctionCall).Name}"" }}");

        Console.WriteLine(@$"{{ ""name"": ""{((UserFunctionCall)c5.FunctionCall).Name}"" }}");

    }

}