//Models
public class Reward_Type
{
    [Key]
    public int Reward_Type_ID { get; set; }

    [Required]
    public string Reward_Type_Name { get; set; }

    [Required]
    public string Reward_Criteria { get; set; }

    public int Inventory_ID { get; set; } // Link to Inventory
    [ForeignKey(nameof(Inventory_ID))]
    public Inventory Inventory { get; set; } // Reference to Inventory item
}

//Viewmodels
public class RewardTypeViewModel
{
    public string Reward_Type_Name { get; set; }
    public string Reward_Criteria { get; set; }
    public int Inventory_ID { get; set; }
}

/controller
[HttpGet]
    [Route("getAllRewardTypes")]
    public async Task<IActionResult> GetAllRewardTypes()
    {
        try
        {
            var rewardTypes = await _appDbContext.Reward_Types
                .Include(rt => rt.Inventory) // Include Inventory details
                .ToListAsync();
            return Ok(rewardTypes);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

    [HttpPost]
    [Route("createRewardType")]
    public async Task<IActionResult> CreateRewardType(RewardTypeViewModel rt)
    {
        try
        {
            var rewardType = new Reward_Type
            {
                Reward_Type_Name = rt.Reward_Type_Name,
                Reward_Criteria = rt.Reward_Criteria,
                Inventory_ID = rt.Inventory_ID
            };
            _appDbContext.Reward_Types.Add(rewardType);
            await _appDbContext.SaveChangesAsync();

            return CreatedAtAction(nameof(GetRewardTypeById), new { id = rewardType.Reward_Type_ID }, rewardType);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

[HttpPost]
    [Route("setReward")]
    public async Task<IActionResult> SetReward(RewardSetViewModel r)
    {
        try
        {
            var reward = new Reward
            {
                Reward_Issue_Date = r.Reward_Issue_Date,
                Reward_Type_ID = r.Reward_Type_ID,
                IsPosted = r.IsPosted
            };
            _appDbContext.Rewards.Add(reward);
            await _appDbContext.SaveChangesAsync();

            // Automatically populate Reward_Member based on criteria
            var members = await _appDbContext.Members // Assuming members criteria is stored in members
                .Where(m => /* apply criteria based on reward type */ true)
                .ToListAsync();

            foreach (var member in members)
            {
                var rewardMember = new Reward_Member
                {
                    Member_ID = member.Member_ID,
                    Reward_ID = reward.Reward_ID,
                    IsRedeemed = false
                };
                _appDbContext.Reward_Members.Add(rewardMember);
            }
            await _appDbContext.SaveChangesAsync();

            return CreatedAtAction(nameof(GetRewardById), new { id = reward.Reward_ID }, reward);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

[HttpPost]
    [Route("redeemReward")]
    public async Task<IActionResult> RedeemReward([FromBody] RewardRedeemViewModel request)
    {
        try
        {
            var rewardMember = await _appDbContext.Reward_Members
                .Include(rm => rm.Reward)
                .ThenInclude(r => r.Reward_Type)
                .FirstOrDefaultAsync(r => r.Reward_ID == request.RewardId && r.Member_ID == request.MemberId);

            if (rewardMember == null)
            {
                return NotFound("Reward not found or not eligible for the member.");
            }

            if (rewardMember.IsRedeemed)
            {
                return BadRequest("Reward is already redeemed.");
            }

            // Reduce inventory quantity
            var inventory = await _appDbContext.Inventories.FindAsync(rewardMember.Reward.Reward_Type.Inventory_ID);
            if (inventory == null || inventory.Inventory_Item_Quantity <= 0)
            {
                return BadRequest("Inventory item is not available.");
            }
            inventory.Inventory_Item_Quantity -= 1;
            _appDbContext.Entry(inventory).State = EntityState.Modified;

            // Mark reward as redeemed
            rewardMember.IsRedeemed = true;
            _appDbContext.Entry(rewardMember).State = EntityState.Modified;

            await _appDbContext.SaveChangesAsync();

            return Ok(new { Status = "Success", Message = "Reward redeemed successfully!" });
        }
        catch (Exception)
        {
            return BadRequest("An error occurred while redeeming the reward.");
        }
    }

public async Task<List<Inventory>> GetAvailableInventoryItems()
{
    return await _appDbContext.Inventories
        .Where(i => i.Inventory_Item_Quantity > 0)
        .ToListAsync();
}

public async Task<bool> ValidateRewardTypeCreation(RewardTypeViewModel rt)
{
    var inventory = await _appDbContext.Inventories.FindAsync(rt.Inventory_ID);
    return inventory != null && inventory.Inventory_Item_Quantity > 0;
}