#nullable enable
// The following would be considered to be optional.
public string? MyOptionalString { get; set; }
// The following would be considered required and throw DynamoDBMarshallingException if the value was not provided.
public string MyRequiredString { get; set; }
#nullable disable
// The following does not have nullable enabled and would consider the string to be optional.
public string MyUnknownString { get; set; }

_ = new Constructor(id: "123", count: 10);
_ = new Initializer { Id = "123", Count = 10 };

[DynamoDBMarshaller]
public partial class Constructor
{
    [DynamoDBMarshallerConstructor]
    public Constructor(string id, int count)
    {
        Count = count;
        Id = id;
    }

    public int Count { get; }
    public string Id { get; }
}

[DynamoDBMarshaller]
public partial class Initializer
{
    public string Id { get; set; }
    public int Count { get; set; }
}

[DynamoDBMarshaller]
public partial record Record([property: DynamoDBHashKey] string Id);

[DynamoDBMarshaller]
public partial class Class
{
    [DynamoDBHashKey]
    public string Id { get; init; }
}

[DynamoDBMarshaller]
public partial struct Struct
{
    [DynamoDBHashKey]
    public string Id { get; init; }
}

[DynamoDBMarshaller]
public readonly partial struct ReadOnlyStruct
{
    [DynamoDBHashKey]
    public string Id { get; init; }
}

[DynamoDBMarshaller]
public readonly partial record struct ReadOnlyRecordStruct([property: DynamoDBHashKey] string Id);

// A typical scenario would be that you would use multiple DynamoDBMarshaller and describe your operations via AccessName.
// If you do not specify an ArgumentType it will use your main entity Type instead which is typically useful for PUT operations.
[DynamoDBMarshaller]
[DynamoDBMarshaller(ArgumentType = typeof((string PersonId, string Firstname)), AccessName = "UpdateFirstName")]
[DynamoDBMarshaller(ArgumentType = typeof(string), AccessName = "GetById")]
public partial class Person
{
    // Will be included as 'PK' in DynamoDB.
    [DynamoDBHashKey("PK")]
    public string Id { get; set; }

    // Will be included as 'Firstname' in DynamoDB.
    public string Firstname { get; set; }

    // Will be included as 'Contact' in DynamoDB.
    [DynamoDBProperty("Contact")]
    public Contact ContactInfo { get; set; }

    // Wont be included in DynamoDB.
    [DynamoDBIgnore]
    public string FirstNameLowercase => Firstname.ToLower();

    public class Contact
    {
        // Will be included as 'Email' in DynamoDB.
        public string Email { get; set; }
    }
}

static PutItemRequest PutPerson()
{
    return new PutItemRequest
    {
        TableName = "MyTable",
        Item = Person.PersonMarshaller.Marshall(new Person
        {
            Firstname = "John",
            Id = Guid.NewGuid().ToString(),
            ContactInfo = new Person.Contact { Email = "john@test.com" }
        })
    };
}

static GetItemRequest CreateGetItemRequest()
{
    return new GetItemRequest
    {
        Key = Person.GetById.PrimaryKeyMarshaller.PartitionKey("123"),
        TableName = "MyTable"
    };
}

static Person DeserializeResponse(GetItemResponse response)
{
    if (response.HttpStatusCode != HttpStatusCode.OK)
        throw new NotImplementedException();
    
    return Person.GetById.Unmarshall(response.Item);
}

static UpdateItemRequest UpdateFirstName()
{
    // Creating an AttributeExpression can be done through string interpolation where the source generator will mimic your DTO types and give you an consistent API to build the attributeExpressions.
    var attributeExpression = Person.UpdateFirstName.ToAttributeExpression(
        ("personId", "John"),
        (dbRef, argRef) => $"{dbRef.Id} = {argRef.PersonId}", // The condition
        (dbRef, argRef) => $"SET {dbRef.Firstname} = {argRef.Firstname}" // The update operation
    );

    // the index can be used to retrieve the expressions in the same order as you provide the string interpolations in the method call above.
    var condition = attributeExpression.Expressions[0];
    var update = attributeExpression.Expressions[1];
    var keys = Person.UpdateFirstName.PrimaryKeyMarshaller.PartitionKey("personId");

    return new UpdateItemRequest
    {
        ConditionExpression = condition,
        UpdateExpression = update,
        ExpressionAttributeNames = attributeExpression.Names,
        ExpressionAttributeValues = attributeExpression.Values,
        Key = keys,
        TableName = "MyTable"
    };
}

// PrimaryKeyMarshaller is used to convert the keys obtained from the [DynamoDBHashKey] and [DynamoDBRangeKey] attributes.
var keyMarshaller = EntityDTO.KeyMarshallerSample.PrimaryKeyMarshaller;

// IndexKeyMarshaller requires an argument that is the index name so it can provide you with the correct conversion based on the indexes you may have.
// It works the same way for both LocalSecondaryIndex and GlobalSecondaryIndex attributes.
var GSIKeyMarshaller = EntityDTO.KeyMarshallerSample.IndexKeyMarshaller("GSI");
var LSIKeyMarshaller = EntityDTO.KeyMarshallerSample.IndexKeyMarshaller("LSI");

[DynamoDBMarshaller(AccessName = "KeyMarshallerSample")]
public partial class EntityDTO
{
    [DynamoDBHashKey("PK")]
    public string Id { get; set; }

    [DynamoDBRangeKey("RK")]
    public string RangeKey { get; set; }

    [DynamoDBLocalSecondaryIndexRangeKey("LSI")]
    public string SecondaryRangeKey { get; set; }

    [DynamoDBGlobalSecondaryIndexHashKey("GSI")]
    public string GlobalSecondaryIndexId { get; set; }

    [DynamoDBGlobalSecondaryIndexRangeKey("GSI")]
    public string GlobalSecondaryIndexRangeKey { get; set; }
}

[DynamoDbMarshallerOptions(Converters = typeof(MyCustomConverters))]
[DynamoDBMarshaller]
public partial record OverriddenConverter([property: DynamoDBHashKey] string Id, DateTime Timestamp);

// Implement a converter, there's also an IReferenceTypeConverter available for ReferenceTypes.
public class UnixEpochDateTimeConverter : IValueTypeConverter<DateTime>
{
    public UnixEpochDateTimeConverter()
    {
    }

    // Convert the AttributeValue into a .NET type.
    public DateTime? Read(AttributeValue attributeValue)
    {
        return long.TryParse(attributeValue.N, out var epoch)
            ? DateTimeOffset.FromUnixTimeSeconds(epoch).DateTime
            : null;
    }

    // Convert the .NET type into an AttributeValue.
    public AttributeValue Write(DateTime element)
    {
        return new AttributeValue { N = new DateTimeOffset(element).ToUnixTimeSeconds().ToString() };
    }
}

// Create a new Converters class
// You don't have to inherit from AttributeValueConverters if you do not want to use the default converters provided.
public class MyCustomConverters : AttributeValueConverters
{
    // If you take constructor parameters, the source generator will recongnize it and change the way you access it into an method.
    // It's recommended to call the method once and save it into a class member.
    public MyCustomConverters()
    {
        // Override the default behaviour.
        DateTimeConverter = new UnixEpochDateTimeConverter();
    }
    // You could add more converter DataMembers as fields or properties to add your own custom conversions.
}

[DynamoDbMarshallerOptions(EnumConversion = EnumConversion.Name)]
[DynamoDBMarshaller]
public partial record EnumBehaviour([property: DynamoDBHashKey] string Id, DayOfWeek Enum);