using Google.Protobuf.WellKnownTypes;

namespace MFiles.Grpc.Samples;

/// <summary>
/// Builders for the messages almost every call needs: object identities, typed values and
/// search conditions.
/// </summary>
public static class MFilesValues
{
    /// <summary>An object: its object type (0 = document) and ID.</summary>
    public static ObjID ObjId(int objectType, int id) =>
        new() { Type = objectType, ItemId = new ItemID { InternalId = id } };

    /// <summary>A specific version of an object. Writes to a checked-in object need this.</summary>
    public static ObjVer ObjVer(int objectType, int id, int version) => new()
    {
        ObjId = ObjId(objectType, id),
        Version = new ObjVerVersion { Type = ObjVerVersionType.Specific, InternalVersion = version },
    };

    // [START typed-values]
    /// <summary>A single-line text value.</summary>
    public static TypedValue Text(string value) =>
        new() { Type = Datatype.Text, Data = new TypedValueUnion { Text = value } };

    /// <summary>An integer value.</summary>
    public static TypedValue Integer(int value) =>
        new() { Type = Datatype.Integer, Data = new TypedValueUnion { Integer = value } };

    /// <summary>A Boolean value.</summary>
    public static TypedValue Boolean(bool value) =>
        new() { Type = Datatype.Boolean, Data = new TypedValueUnion { Boolean = value } };

    /// <summary>A date value: midnight UTC of the day.</summary>
    public static TypedValue Date(DateOnly date) => new()
    {
        Type = Datatype.Date,
        Data = new TypedValueUnion
        {
            Date = date.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc).ToTimestamp(),
        },
    };

    /// <summary>A timestamp value (date and time, UTC).</summary>
    public static TypedValue Timestamp(DateTime utc) => new()
    {
        Type = Datatype.Timestamp,
        Data = new TypedValueUnion { Timestamp = utc.ToTimestamp() },
    };

    /// <summary>A lookup: item <paramref name="item"/> of value list (or object type)
    /// <paramref name="valueList"/>.</summary>
    public static TypedValue Lookup(int valueList, int item) => new()
    {
        Type = Datatype.Lookup,
        Data = new TypedValueUnion { Lookup = LookupItem(valueList, item) },
    };

    /// <summary>A multi-select lookup.</summary>
    public static TypedValue MultiSelectLookup(int valueList, params int[] items) => new()
    {
        Type = Datatype.MultiSelectLookup,
        Data = new TypedValueUnion
        {
            MultiSelectLookup = new MultiSelectLookup
            {
                Values = { items.Select(item => LookupItem(valueList, item)) },
            },
        },
    };

    /// <summary>An empty value of the given data type; it clears a property.</summary>
    public static TypedValue Empty(Datatype type) => new() { Type = type, IsNullValue = true };

    private static Lookup LookupItem(int valueList, int item) =>
        new() { ValueListItemInfo = new ItemInfo { ObjId = ObjId(valueList, item) } };
    // [END typed-values]

    /// <summary>A property value: property definition <paramref name="propertyDef"/>.</summary>
    public static PropertyValue Property(int propertyDef, TypedValue value) =>
        new() { PropertyDef = propertyDef, Value = value };

    // [START conditions]
    /// <summary>A condition on a property value, e.g. property 100 (Class) equals a lookup.</summary>
    public static SearchCondition PropertyCondition(
        int propertyDef, ConditionType type, TypedValue value) => new()
    {
        Expression = new Expression
        {
            Type = ExpressionType.PropertyValue,
            Data = new ExpressionUnion
            {
                PropertyValue = new ExpressionUnion.Types.PropertyValueData
                {
                    PropertyDef = propertyDef,
                },
            },
        },
        Type = type,
        Value = value,
    };

    /// <summary>A condition on a status value, e.g. the object type or the deleted flag.</summary>
    public static SearchCondition StatusCondition(
        StatusType status, ConditionType type, TypedValue value) => new()
    {
        Expression = new Expression
        {
            Type = ExpressionType.StatusValue,
            Data = new ExpressionUnion
            {
                StatusValue = new ExpressionUnion.Types.StatusValueData { Type = status },
            },
        },
        Type = type,
        Value = value,
    };

    /// <summary>Objects of one object type. Value list -11 lists the object types.</summary>
    public static SearchCondition IsObjectType(int objectType) =>
        StatusCondition(StatusType.ObjectType, ConditionType.Equal, Lookup(-11, objectType));

    /// <summary>Objects that are not deleted.</summary>
    public static SearchCondition IsNotDeleted() =>
        StatusCondition(StatusType.IsDeleted, ConditionType.Equal, Boolean(false));
    // [END conditions]
}