//Models
//Reward
public class Reward
{
    [Key]

    public int Reward_ID { get; set; }

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

    [Required]
    public DateTime Reward_Issue_Date { get; set; }

    public int Member_ID { get; set; }

    [ForeignKey(nameof(Member_ID))]
    public Member Member { get; set; }

    
    public int Reward_Type_ID { get; set; }


    [ForeignKey(nameof(Reward_Type_ID))]
    public Reward_Type Reward_Type { get; set; }


    public bool IsRedeemed { get; set; } // New property to track redemption status
}

//RewardType
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; }
}

//Reward_Member
public class Reward_Member
{
    [Key]
    public int Reward_Member_ID { get; set; }

    public int Number_Of_Qualified_Members { get; set; }

    public int Member_ID { get; set; }

    [ForeignKey(nameof(Member_ID))]

    public Member Member { get; set; }


    public int Reward_ID { get; set; }

    [ForeignKey(nameof(Reward_ID))]

    public Reward Reward { get; set; }
}

//ViewModels
//RewardViewModel
public class RewardViewModel
{
    public int MemberId { get; set; }
    public int RewardId { get; set; }
}

//AppDbContext
//Reward Seed Data
var Rewards = new Reward[]
{
    new Reward { Reward_ID = 1, Prize = "Free Gym Membership", Reward_Issue_Date = new DateTime(2024, 4, 10), Member_ID = 1, Reward_Type_ID = 1 }

};
builder.Entity<Reward>().HasData(Rewards);


//Reward_Member Seed Data
var Reward_Members = new Reward_Member[]
{
    new Reward_Member{ Reward_Member_ID = 1,Number_Of_Qualified_Members = 3,Member_ID = 1, Reward_ID = 1}
};
builder.Entity<Reward_Member>().HasData(Reward_Members);

//Controller
[Route("api/[controller]")]
[ApiController]
public class RewardController : ControllerBase
{
    private readonly AppDbContext _appDbContext;

    public RewardController(AppDbContext appDbContext)
    {
        _appDbContext = appDbContext;
    }

    [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
                
            };
            _appDbContext.Reward_Types.Add(rewardType);
            await _appDbContext.SaveChangesAsync();

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

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

    [HttpGet]
    [Route("getRewardTypeById/{id}")]
    public async Task<IActionResult> GetRewardTypeById(int id)
    {
        try
        {
            var rewardType = await _appDbContext.Reward_Types.FindAsync(id);

            if (rewardType == null)
            {
                return NotFound();
            }

            return Ok(rewardType);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

    [HttpPut]
    [Route("updateRewardType/{id}")]
    public async Task<IActionResult> UpdateRewardType(int id, [FromBody] RewardTypeViewModel rt)
    {
        try
        {
            var rewardType = await _appDbContext.Reward_Types.FindAsync(id);

            if(rewardType == null)
            {
                return NotFound();
            }

            //rewardType = new Reward_Type
            //{
            //    Reward_Type_Name = rt.Reward_Type_Name,
            //    Reward_Criteria = rt.Reward_Criteria
            //};

            rewardType.Reward_Type_Name = rt.Reward_Type_Name;
            rewardType.Reward_Criteria = rt.Reward_Criteria;

            _appDbContext.Entry(rewardType).State = EntityState.Modified;
            await _appDbContext.SaveChangesAsync();

            return NoContent();
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

    [HttpDelete]
    [Route("deleteRewardType/{id}")]
    public async Task<IActionResult> DeleteRewardType(int id)
    {
        try
        {
            var rewardType = await _appDbContext.Reward_Types.FindAsync(id);

            if(rewardType == null)
            {
                return NotFound();
            }

            _appDbContext.Reward_Types.Remove(rewardType);
            await _appDbContext.SaveChangesAsync();

            return NoContent();
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }



    [HttpPost]
    [Route("redeemReward")]
    public async Task<IActionResult> RedeemReward([FromBody] RewardViewModel request)
    {
        try
        {
            // Fetch the reward by ID
            var reward = await _appDbContext.Rewards
                                            .FirstOrDefaultAsync(r => r.Reward_ID == request.RewardId && r.Member_ID == request.MemberId);

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

            // Check if the reward is already redeemed
            if (reward.IsRedeemed)
            {
                return BadRequest("Reward is already redeemed.");
            }

            // Mark the reward as redeemed
            reward.IsRedeemed = true;
            _appDbContext.Entry(reward).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.");
        }
    }

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

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

    [HttpGet]
    [Route("getRewardById/{id}")]
    public async Task<IActionResult> GetRewardById(int id)
    {
        try
        {
            var reward = await _appDbContext.Reward_Types.FindAsync(id);

            if (reward == null)
            {
                return NotFound();
            }

            return Ok(reward);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

    [HttpGet]
    [Route("getAllRewards")]
    public async Task<IActionResult> GetAllRewards()
    {
        try
        {
            var rewards = await _appDbContext.Rewards.ToListAsync();
            return Ok(rewards);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }
}