using System;
using System.Collections.Generic;
using System.Data;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Threading.Tasks;
using Google.Apis.Auth.OAuth2;
using Google.Cloud.Firestore;
using Google.Cloud.Firestore.V1;
using Grpc.Auth;
using Grpc.Core;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using Microsoft.Net.Http.Headers;
using Newtonsoft.Json;
using Teso_API.Methods.Controllers;
using Teso_API.Models;

namespace Teso_API.Controllers
{
    [AllowAnonymous, Route("coupons")]
    [ApiController]
    public class CouponsController : ControllerBase
    {
        private readonly TESOContext _context;
        private FirestoreDb db;
        public CouponsController(TESOContext context)
        {
            _context = context;

           db = new FirestoreDbBuilder
            {
                ProjectId = ServerLocation.credentials.project_id,
                ChannelCredentials = GoogleCredential.FromJson(JsonConvert.SerializeObject(ServerLocation.credentials)).ToChannelCredentials(),
            }.Build();
        }

        [Authorize]
        [Route("acquiredcoupons"), HttpGet]
        public async Task<ActionResult<IEnumerable<CouponDetails>>> GetCouponsHeads()
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;

            string connString = ServerLocation.connection;
            string sprocname = "[dbo].[usp_acquiredCoupons_Get]";

            using (SqlConnection conn = new SqlConnection(connString))
            {
                try
                {
                    string result = "";
                    conn.Open();

                    using (SqlCommand cmd = new SqlCommand(sprocname, conn))
                    {
                        cmd.CommandType = System.Data.CommandType.StoredProcedure;

                        cmd.Parameters.AddWithValue("@userGUID", userID);
                        cmd.ExecuteNonQuery();
                        using (SqlDataReader sdr = cmd.ExecuteReader())
                        {
                            while (sdr.Read())
                            {
                                result += sdr[0];
                            }
                        }
                    }
                    conn.Close();
                    List<CouponDetails> coupons = JsonConvert.DeserializeObject<List<CouponDetails>>(result);

                    return coupons;
                }
                catch (Exception ex)
                {
                    conn.Close();
                    return null;
                }
            }
        }

        //set Expiration after algorithm design
        [Authorize]
        [Route("proximity"), HttpPost]
        public async Task<ActionResult<IEnumerable<ProximityCoupon>>> ProximityCoupons(ProximityPosition position)
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;

            List<string> businesses = await _context.CouponsHeads.AsQueryable().Where(p => p.Type == "TESCP004" || p.Type == "TESCP003" &&
            p.State == "active" && p.Expiration > DateTime.Now).Select(b => b.BusinessId).Distinct().ToListAsync();
            List<ProximityCoupon> coupons = new List<ProximityCoupon>();
            List<string> declined = await _context.CouponsDeclineds.AsQueryable().Where(u => u.UserGuid == userID).Select(p => p.CouponId).ToListAsync();
            List<string> acquired = await _context.UserCouponBanks.AsQueryable().Where(u => u.UserGuid == userID).Select(p => p.CouponId).ToListAsync();

            foreach (string p in businesses)
            {
                var param = new SqlParameter[] {
                        new SqlParameter() {
                            ParameterName = "@Status",
                            SqlDbType =  System.Data.SqlDbType.VarChar,
                            Direction = System.Data.ParameterDirection.Input,
                            Value = "active"
                        },
                    new SqlParameter()
                        {
                             ParameterName = "@businessID",
                            SqlDbType =  System.Data.SqlDbType.VarChar,
                            Direction = System.Data.ParameterDirection.Input,
                            Value = p
                        }

            };
                TesoBusinessDetail tesoBusiness = await _context.TesoBusinessDetails.AsQueryable().Where(b => b.BusinessId == p).FirstOrDefaultAsync();
                if (tesoBusiness != null && !String.IsNullOrEmpty(tesoBusiness.BusinessLat) && !String.IsNullOrEmpty(tesoBusiness.BusinessLng))
                {
                    Position businessPosition = new Position
                    {
                        Latitude = double.Parse(tesoBusiness.BusinessLat),
                        Longitude = double.Parse(tesoBusiness.BusinessLng)
                    };
                    Position position1 = new Position
                    {
                        Latitude = position.latitude,
                        Longitude = position.longitude
                    };
                    HaversineClass haversine = new HaversineClass();
                    double distance = haversine.Distance(pos1: position1, pos2: businessPosition, type: DistanceType.Miles);

                    if (distance <= 1.0)
                    {
                        List<ProximityCoupon> cc = await _context.ProximityCoupons.FromSqlRaw("Select ch.couponID,ch.businessID as BusinessBusinessID,ch.productID as targetID,p.pname as targetName," +
                             "p.productImage as targetImage,p.unitPrice as targetCost,p.pdescription as targetDescription,cd.condition as condition," +
                             "ch.lowerlimit as LowerLimit,ch.upperlimit as UpperLimit, ch.expiration as Expiration,ch.businessID as BusinessID,ch.quantity as Quantity," +
                             "ch.state as State, cT.typeName as Type from CouponsHead ch Inner Join TesoBusinessDetail b on b.businessID = ch.businessID Inner Join Products p on p.productId = ch.productID Inner Join " +
                             "CouponTypes cT on cT.typeCode = ch.type Inner Join CouponCondition cd on cd.couponID = ch.couponID where ch.businessID = @businessID and ch.state = @Status", param).AsQueryable()
                             .Where(d => !declined.Contains(d.CouponId) && d.Expiration > DateTime.Now && !acquired.Contains(d.CouponId) && d.Type.ToLower().Contains("proximity"))
                             .ToListAsync();

                        coupons.AddRange(cc);
                    }
                }
            }
            return coupons;
        }

        [Authorize]
        [Route("declineCoupon"), HttpPost]
        public async Task<ActionResult> DeclineCoupons(CouponsHead coupon)
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;

            CouponsDeclined declined = new CouponsDeclined();
            declined.DateDeclined = DateTime.Now;
            declined.CouponId = coupon.CouponId;
            declined.UserGuid = userID;
            declined.CountId = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + userID;

            _context.CouponsDeclineds.Add(declined);

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                return Conflict();
            }

            return Ok();
        }

        [Authorize]
        [Route("acceptCoupon"), HttpPost]
        public async Task<ActionResult> AcceptCoupons(CouponsHead coupon)
        {
            CouponsHead head = await _context.CouponsHeads.AsQueryable().Where(d => d.CouponId == coupon.CouponId).FirstOrDefaultAsync();
            if (head.Quantity > 0 && (head.Quantity - coupon.Quantity) >= 0)
            {
                var accessToken = Request.Headers[HeaderNames.Authorization];
                string token = accessToken;
                token = token.Substring(6).Trim();
                var handler = new JwtSecurityTokenHandler();
                var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
                string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;
                string username = jwtToken.Claims.First(claim => claim.Type == "username").Value;

                List<UserCouponBank> banked = new List<UserCouponBank>();
                List<CouponAcquisition> couponAcquisitions = new List<CouponAcquisition>();
                string shopName = await _context.TesoBusinessDetails.AsQueryable().Where(b => b.BusinessId == coupon.BusinessId).Select(b => b.BusinessName).FirstOrDefaultAsync();
                string couponType = coupon.Type;
                Product product = await _context.Products.AsQueryable().Where(b => b.ProductId == coupon.TargetProduct).FirstOrDefaultAsync();

                double priceDiscounted = double.Parse(product.UnitPrice.ToString()) * (coupon.LowerLimit / 100);

                int cost = CouponRateCalculator.GetRate(priceDiscounted);

                for (int i = 0; i < coupon.Quantity; i++)
                {
                    CouponAcquisition acquisition = new CouponAcquisition();
                    acquisition.Dateacquired = DateTime.Now;
                    acquisition.CouponId = coupon.CouponId;
                    acquisition.UserGuid = userID;
                    acquisition.CountId = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 100000000) + userID + i;
                    if (couponType == "TESCP001" || couponType == "TESCP004")
                    {
                        acquisition.Worth = 100;
                    }
                    else
                    {
                        acquisition.Worth = coupon.LowerLimit;
                    }
                    acquisition.SilverCost = cost;
                    acquisition.Mode = "purchased";
                    acquisition.Expiration = coupon.Expiration;

                    couponAcquisitions.Add(acquisition);
                    UserCouponBank bank = new UserCouponBank();
                    bank.CountId = coupon.CouponId + String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + userID;
                    bank.CouponId = coupon.CouponId;
                    bank.UserGuid = userID;
                    if (couponType == "TESCP001" || couponType == "TESCP004")
                    {
                        bank.Worth = 100;
                        bank.Expiration = DateTime.Now.AddMinutes(60);
                    }
                    else
                    {
                        bank.Worth = coupon.LowerLimit;
                        bank.Expiration = await _context.CouponsHeads.AsQueryable().Where(i => i.CouponId == coupon.CouponId).Select(e => e.Expiration).FirstOrDefaultAsync();
                    }
                    acquisition.Expiration = bank.Expiration;
                    banked.Add(bank);

                }
                UserFinance finance = await _context.UserFinances.AsQueryable().Where(u => u.UserGUID == userID).FirstOrDefaultAsync();
                finance.Silver = finance.Silver - (cost * coupon.Quantity.Value);

                UserTransaction transaction = new UserTransaction();
                transaction.RealCash = 0;
                transaction.CoinType = await _context.CoinTypes.AsQueryable().Where(c => c.TypeName.ToLower().Contains("silver")).Select(s => s.TypeCode).AsNoTracking().FirstOrDefaultAsync(); ;
                transaction.Comments = "coupon acquisition ... coupon id " + coupon.CouponId;
                transaction.CoinAmount = cost * coupon.Quantity.Value;
                transaction.Timestamp = DateTime.Now;
                transaction.TransactionID = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + userID;
                transaction.UserGUID = userID;
                transaction.TransactionType = await _context.TransactionTypes.AsQueryable().Where(c => c.TypeName.ToLower().Contains("silver debit")).Select(c => c.TypeCode).AsNoTracking().FirstOrDefaultAsync();

                head.Quantity -= coupon.Quantity;

                await SilverBankOperations.DepositToBank(transaction.CoinAmount.Value, _context);

                _context.CouponAcquisitions.AddRange(couponAcquisitions);
                _context.UserCouponBanks.AddRange(banked);
                _context.UserTransactions.Add(transaction);

                string message;
                string message2;

                if (coupon.Quantity > 1)
                {
                    message = "You acquired " + coupon.Quantity + " " + couponType + " vouchers for " + product.Name + " from " + shopName + " with " + cost.ToString() +
                        " silver coins ";
                    message2 = username + " acquired " + coupon.Quantity + " " + couponType + " vouchers for " + product.Name + " from " + shopName;
                }
                else
                {
                    message = "You acquired a " + couponType + " voucher for " + product.Name + " from " + shopName + " with " + cost.ToString() +
                        " silver coins ";
                    message2 = username + " acquired " + coupon.Quantity + " " + couponType + " vouchers for " + product.Name + " from " + shopName;
                }

                if (couponType == "TESCP001" || couponType == "TESCP004")
                    message = message + "which expires in 60 minutes";
                try
                {
                    await _context.SaveChangesAsync();
                    DocumentReference docRef = db.Collection(ServerLocation.user_notifications).Document(userID).Collection(userID).Document();
                    Dictionary<string, object> user = new Dictionary<string, object>
                    {
                        { "notificationType", "redeemable" },
                        { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                        { "message", message },
                        { "couponID", coupon.CouponId },
                        { "productImage", product.ProductImage },
                    };

                    DocumentReference BusdocRef = db.Collection(ServerLocation.business_notifications).Document(product.BusinessId).Collection(product.BusinessId).Document();
                    Dictionary<string, object> Bususer = new Dictionary<string, object>
                    {
                        { "notificationType", "couponAcquisition" },
                        { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                        { "message", message2 },
                        { "couponID", coupon.CouponId },
                        { "userID", userID},
                    };
                    await docRef.SetAsync(user);
                    await BusdocRef.SetAsync(Bususer);
                }
                catch (DbUpdateException)
                {
                    return Conflict();
                }

                return Ok(message);
            }
            else
            {
                return StatusCode(999);
            }
        }

        [Authorize]
        [Route("qrCoupon"), HttpPost]
        public async Task<ActionResult<IEnumerable<CouponDetails>>> GetShopCoupons([FromBody] string businessID)
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;

            try
            {
                DailyVisit visit = await _context.DailyVisits.AsQueryable().Where(u => u.UserGuid == userID && u.Timestamp.Value.Month == DateTime.Now.Month &&
                    u.Timestamp.Value.Day == DateTime.Now.Day && u.Timestamp.Value.Year == DateTime.Now.Year).FirstOrDefaultAsync();

                if (visit == null)
                {
                    visit = new DailyVisit
                    {
                        BusinessId = businessID,
                        CountId = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + userID,
                        Timestamp = DateTime.Now,
                        UserGuid = userID
                    };

                    _context.DailyVisits.Add(visit);

                    await _context.SaveChangesAsync();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
            var param = new SqlParameter[] {
                        new SqlParameter() {
                            ParameterName = "@user",
                            SqlDbType =  System.Data.SqlDbType.VarChar,
                            Direction = System.Data.ParameterDirection.Input,
                            Value = userID
                        },
                    new SqlParameter()
                        {
                             ParameterName = "@businessID",
                            SqlDbType =  System.Data.SqlDbType.VarChar,
                            Direction = System.Data.ParameterDirection.Input,
                            Value = businessID
                        }

            };
            string connString = ServerLocation.connection;
            string sprocname = "[dbo].[usp_scanqrcode_Get]";

            using (SqlConnection conn = new SqlConnection(connString))
            {
                try
                {
                    string result = "";
                    conn.Open();

                    using (SqlCommand cmd = new SqlCommand(sprocname, conn))
                    {
                        cmd.CommandType = System.Data.CommandType.StoredProcedure;

                        cmd.Parameters.AddWithValue("@userGUID", userID);
                        cmd.Parameters.AddWithValue("@businessID", businessID);
                        cmd.ExecuteNonQuery();
                        using (SqlDataReader sdr = cmd.ExecuteReader())
                        {
                            while (sdr.Read())
                            {
                                result += sdr[0];
                            }
                        }
                    }
                    conn.Close();
                    List<CouponDetails> coupons = JsonConvert.DeserializeObject<List<CouponDetails>>(result);

                    return coupons;
                }
                catch (Exception ex)
                {
                    conn.Close();
                    return null;
                }
            }
                //List<CouponDetails> coupons = new List<CouponDetails>();
                //List<CouponDetails> acquired = await _context.Details.FromSqlRaw("Select ch.couponID as CouponID,ch.businessID as BusinessId,ct.TypeName as Type,ch.quantity as Quantity," +
                //    "ch.expiration as Expiration,ca.worth as Worth,ch.state as State,ch.businessID as IssuerBusinessID,ch.productID as TargetProductID,ch.lowerLimit as LowerLimit,ch.upperLimit as UpperLimit " +
                //    ",ch.productID as ProductCost,ca.countID as CountID, cd.condition as condition From CouponsHead ch Inner Join CouponTypes ct on ch.type = ct.typeCode Inner Join UserCouponBank ca on ca.couponID = ch.couponID " +
                //    "Inner Join Products p on p.productID = ch.productID Inner Join CouponCondition cd on ch.couponID = cd.CouponID where ca.userGUID = @user and ch.businessID = @businessID", param)
                //    .AsQueryable().Where(e => e.Expiration > DateTime.Now && e.State == "active").ToListAsync();
                //coupons.AddRange(acquired);

                //List<CouponDetails> shop = await _context.Details.FromSqlRaw("Select ch.couponID as CouponID,ch.businessID as BusinessId,ct.TypeName as Type,ch.quantity as Quantity," +
                //    "ch.expiration as Expiration,(Cast(0.0 as float)) as Worth,ch.state as State,ch.businessID as IssuerBusinessID,ch.productID as TargetProductID,ch.lowerLimit as LowerLimit,ch.upperLimit as UpperLimit" +
                //    ",ch.productID as ProductCost,'null' as CountID, cd.condition as condition From CouponsHead ch Inner Join CouponTypes ct on ch.type = ct.typeCode Inner Join Products p on p.productID = ch.productID " +
                //    "Inner Join CouponCondition cd on ch.couponID = cd.CouponID where ch.businessID = @businessID", param).AsQueryable()
                //    .Where(e => !acquired.Contains(e) && e.Expiration > DateTime.Now && e.State == "active").ToListAsync();

                //coupons.AddRange(shop);

                //foreach (CouponDetails details in coupons)
                //{
                //    details.Issuer = await _context.TesoBusinessDetails.AsQueryable().Where(b => b.BusinessId == details.BusinessId).FirstOrDefaultAsync();
                //    details.Target = await _context.Products.AsQueryable().Where(b => b.ProductId == details.ProductCost).FirstOrDefaultAsync();
                //    if (String.IsNullOrEmpty(details.condition)) details.condition = "none";
                //}

        }

        [Authorize]
        [Route("viewCoupon"), HttpPost]
        public async Task<ActionResult> ViewCoupons(CouponsHead head)
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;

            CouponDetails coupon = new CouponDetails();
            coupon.BusinessId = head.BusinessId;
            coupon.CouponId = head.CouponId;
            coupon.Expiration = head.Expiration;
            coupon.lowerLimit = await _context.CouponsHeads.AsQueryable().Where(d => d.CouponId == head.CouponId).Select(e => e.LowerLimit).FirstOrDefaultAsync();
            coupon.upperLimit = await _context.CouponsHeads.AsQueryable().Where(d => d.CouponId == head.CouponId).Select(e => e.UpperLimit).FirstOrDefaultAsync();
            coupon.Quantity = head.Quantity;
            coupon.State = head.State;
            coupon.Target = await _context.Products.AsQueryable().Where(p => p.ProductId == head.TargetProduct).FirstOrDefaultAsync();
            coupon.Issuer = await _context.TesoBusinessDetails.AsQueryable().Where(p => p.BusinessId == head.BusinessId).FirstOrDefaultAsync();
            coupon.Type = head.Type;



            DocumentReference docRef = db.Collection("recentlyViewed").Document("users").Collection(userID).Document(coupon.CouponId);
            Dictionary<string, object> user = new Dictionary<string, object>
                {
                    {"couponId", coupon.CouponId },
                    {"businessId",coupon.Issuer.BusinessId },
                    { "type", coupon.Type},
                    { "quantity", coupon.Quantity },
                    { "expiration",coupon.Expiration.Value.ToString("yyyy-MM-dd HH:mm:ss")},
                    { "worth",coupon.Worth},
                    { "state", coupon.State},
                    { "productCost", coupon.Target.UnitPrice.ToString()},
                    {"businessName",coupon.Issuer.BusinessName},
                    {"businessDescription",coupon.Issuer.BusinessDescription},
                    {"businessCategory",coupon.Issuer.BusinessCategory},
                    {"businessAddress",coupon.Issuer.BusinessAddress},
                    {"businessContact",coupon.Issuer.BusinessContact},
                    {"businessLogo",coupon.Issuer.BusinessLogo},
                    {"businessLat",coupon.Issuer.BusinessLat},
                    {"businessLng",coupon.Issuer.BusinessLng},
                    {"productId",coupon.Target.ProductId},
                    {"name",coupon.Target.Name},
                    {"description",coupon.Target.Description},
                    {"category",coupon.Target.Category},
                    {"unitPrice",coupon.Target.UnitPrice.ToString()},
                    {"productImage",coupon.Target.ProductImage},
                    {"lowerLimit",coupon.lowerLimit.ToString()},
                    {"upperLimit",coupon.upperLimit.ToString()},
                    {"dateViewed",new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                };

            if (TrendingExists(head.TargetProduct))
            {
                TrendingProduct trend = await _context.TrendingProducts.AsQueryable().Where(p => p.ProductId == head.TargetProduct).FirstOrDefaultAsync();
                trend.Views += 1;
            }
            else
            {
                TrendingProduct trend = new TrendingProduct();
                trend.ProductId = coupon.Target.ProductId;
                trend.Views = 1;
                _context.TrendingProducts.Add(trend);
            }

            try
            {
                await _context.SaveChangesAsync();
                await docRef.SetAsync(user);
            }
            catch (DbUpdateException)
            {
                return StatusCode(500);
            }
            return Ok();
        }

        [Authorize]
        [Route("giftCoupon"), HttpPost]
        public async Task<ActionResult> GiftCoupons(CouponsHead details)
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;

            TesoUserDetail userT = await _context.TesoUserDetails.AsQueryable().Where(u => u.UserGUID == userID).FirstOrDefaultAsync();
            UserCouponBank userCoupon = await _context.UserCouponBanks.AsQueryable().Where(c => c.CountId == details.State).FirstOrDefaultAsync();
            Product product = await _context.Products.AsQueryable().Where(p => p.ProductId == details.TargetProduct).FirstOrDefaultAsync();
            string type = await _context.CouponsHeads.AsQueryable().Where(c => c.CouponId == details.CouponId).Select(t => t.Type).AsNoTracking().FirstOrDefaultAsync();

            UserCouponBank recipient = new UserCouponBank();
            recipient.CountId = details.CouponId + String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + details.Type;
            recipient.CouponId = details.CouponId;
            recipient.UserGuid = details.Type;
            recipient.Worth = (details.LowerLimit / 100) * userCoupon.Worth;
            recipient.Expiration = userCoupon.Expiration;


            userCoupon.Worth -= recipient.Worth;

            CouponAcquisition acquisition = new CouponAcquisition();
            acquisition.CountId = details.CouponId + String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + details.Type;
            acquisition.CouponId = details.CouponId;
            acquisition.Dateacquired = DateTime.Now;
            acquisition.Expiration = userCoupon.Expiration;
            acquisition.Mode = "gifted";
            acquisition.SilverCost = 0;
            acquisition.UserGuid = recipient.UserGuid;
            acquisition.Worth = recipient.Worth;

            if (userCoupon.Worth == 0 || type == "TESCP001" || type == "TESCP004")
            {
                _context.Remove(userCoupon);
            }

            _context.UserCouponBanks.Add(recipient);
            _context.CouponAcquisitions.Add(acquisition);

            try
            {
                await _context.SaveChangesAsync();
                string message = "";
                if (type == "TESCP001" || type == "TESCP004")
                {
                    message = userT.Firstname + " " + userT.Surname + " has gifted you a " + details.BusinessId + "'s Freebie voucher for " + product.Name;
                }
                else
                {
                    message = userT.Firstname + " " + userT.Surname + " has gifted you a " + details.BusinessId + "'s voucher worth "
                       + recipient.Worth.ToString() + " % OFF for " + product.Name;
                }
                DocumentReference docRef = db.Collection(ServerLocation.user_notifications).Document(recipient.UserGuid).Collection(recipient.UserGuid).Document();
                Dictionary<string, object> user = new Dictionary<string, object>
                {
                    { "notificationType", "gifted" },
                    { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                    { "message", message },
                    { "couponID", details.CouponId },
                    { "productImage", product.ProductImage },
                    { "recipient", recipient.UserGuid },
                };
                await docRef.SetAsync(user);
            }
            catch (Exception ex)
            {
                return BadRequest();
            }
            return Ok();
        }

        [Authorize]
        [Route("productCoupon"), HttpPost]
        public async Task<ActionResult<IEnumerable<CouponDetails>>> GetProductCoupons([FromBody] string productID)
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;
            List<CouponDetails> coupons = await (from c in _context.CouponsHeads.AsQueryable()
                                                 join ct in _context.CouponTypes on c.Type equals ct.TypeCode
                                                 join p in _context.Products on c.TargetProduct equals p.ProductId
                                                 join con in _context.CouponConditions on c.CouponId equals con.CouponId into Conditions
                                                 from cond in Conditions.DefaultIfEmpty()
                                                 where p.ProductId == productID && c.Quantity > 0 && c.State == "active"
                                                 && (c.Type == "TESCP001" || c.Type == "TESCP002")
                                                 select new CouponDetails()
                                                 {
                                                     BusinessId = p.BusinessId,
                                                     condition = cond.Condition,
                                                     countID = c.CouponId,
                                                     CouponId = c.CouponId,
                                                     Expiration = c.Expiration,
                                                     Issuer = _context.TesoBusinessDetails.AsQueryable().Where(b => b.BusinessId == p.BusinessId).FirstOrDefault(),
                                                     lowerLimit = c.LowerLimit,
                                                     ProductCost = p.ProductId,
                                                     Quantity = c.Quantity,
                                                     State = c.State,
                                                     Target = p,
                                                     Type = ct.TypeName,
                                                     upperLimit = c.UpperLimit,
                                                     Worth = 0

                                                 }
                                                 ).ToListAsync();

            //List<CouponDetails> coupons = await _context.Details.FromSqlRaw("Select ch.couponID as CouponID,ch.businessID as BusinessId,ct.TypeName as Type,ch.quantity as Quantity," +
            //    "ch.expiration as Expiration,(Cast(0.0 as float)) as Worth,ch.state as State,ch.businessID as IssuerBusinessID,ch.productID as TargetProductID,ch.lowerLimit as LowerLimit,ch.upperLimit as UpperLimit" +
            //    ",ch.productID as ProductCost,'null' as CountID, cd.condition as condition From CouponsHead ch Inner Join CouponTypes ct on ch.type = ct.typeCode Inner Join Products p on p.productID = ch.productID " +
            //    "Inner Join CouponCondition cd on ch.couponID = cd.CouponID where ch.productID = @productID", param).AsQueryable()
            //    .Where(e => e.Expiration > DateTime.Now && e.State == "active").ToListAsync();

            //foreach (CouponDetails details in coupons)
            //{
            //    details.Issuer = await _context.TesoBusinessDetails.AsQueryable().Where(b => b.BusinessId == details.BusinessId).FirstOrDefaultAsync();
            //    details.Target = await _context.Products.AsQueryable().Where(b => b.ProductId == details.ProductCost).FirstOrDefaultAsync();
            //    if (String.IsNullOrEmpty(details.condition)) details.condition = "none";
            //}

            return coupons;
        }

        [Route("redeemCoupon"), HttpPost]
        public async Task<ActionResult<UserFinance>> RedeemCoupons(CouponDetails coupon)
        {

            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;
            string username = jwtToken.Claims.First(claim => claim.Type == "username").Value;


            try
            {
                UserCouponBank bank = await _context.UserCouponBanks.AsQueryable().Where(u => u.UserGuid == userID && u.CouponId == coupon.CouponId).FirstOrDefaultAsync();
                string type = await _context.CouponsHeads.AsQueryable().Where(c => c.CouponId == coupon.CouponId).Select(t => t.Type).AsNoTracking().FirstOrDefaultAsync();
                CouponAcquisition acquiredMain = new CouponAcquisition();
                CouponAcquisition acquired = await _context.CouponAcquisitions.AsQueryable().Where(u => u.UserGuid == userID && u.CouponId == coupon.CouponId).FirstOrDefaultAsync();
                int calculated = 0;
                if (acquired.Mode == "gifted")
                {
                    acquiredMain = await _context.CouponAcquisitions.AsQueryable().Where(u => u.Mode.ToLower() == "purchased" && u.CouponId == coupon.CouponId).FirstOrDefaultAsync();

                    int refund;
                    if (type == "TESCP001" || type == "TESCP004")
                    {
                        refund = acquiredMain.SilverCost.Value;
                    }
                    else
                    {
                        double percentageWorth = (acquired.Worth.Value / acquiredMain.Worth.Value);
                        calculated = RedemptionReturn.CalculateReturns(acquired.SilverCost.Value);
                        refund = (int)Math.Round((calculated - (calculated / percentageWorth) * 100), MidpointRounding.ToPositiveInfinity);
                    }
                    if (refund > 0)
                    {
                        UserFinance finance = await _context.UserFinances.AsQueryable().Where(u => u.UserGUID == acquiredMain.UserGuid).FirstOrDefaultAsync();
                        finance.Silver += refund;

                    }
                    UserTransaction transaction = new UserTransaction();
                    transaction.RealCash = 0;
                    transaction.CoinType = await _context.CoinTypes.AsQueryable().Where(c => c.TypeName.ToLower().Contains("silver")).Select(s => s.TypeCode).AsNoTracking().FirstOrDefaultAsync(); ;
                    transaction.Comments = "coupon redemption ... coupon id " + coupon.CouponId;
                    transaction.CoinAmount = refund;
                    transaction.Timestamp = DateTime.Now;
                    transaction.TransactionID = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + userID;
                    transaction.UserGUID = userID;
                    transaction.TransactionType = await _context.TransactionTypes.AsQueryable().Where(c => c.TypeName.ToLower().Contains("silver credit")).Select(c => c.TypeCode).AsNoTracking().FirstOrDefaultAsync();

                    _context.UserTransactions.Add(transaction);

                    bool possible = await SilverBankOperations.WithdrawFromBank(refund, _context);

                    if (!possible)
                        return StatusCode(500);
                }
                else
                {
                    if (type == "TESCP001" || type == "TESCP004" || type == "TESCP005" || type == "TESCP006")
                    {
                        calculated = acquired.SilverCost.Value;
                    }
                    else
                    {
                        calculated = RedemptionReturn.CalculateReturns(acquired.SilverCost.Value);
                    }
                    UserFinance finance = await _context.UserFinances.AsQueryable().Where(u => u.UserGUID == acquired.UserGuid).FirstOrDefaultAsync();
                    finance.Silver += calculated;

                    UserTransaction transaction = new UserTransaction();
                    transaction.RealCash = 0;
                    transaction.CoinType = await _context.CoinTypes.AsQueryable().Where(c => c.TypeName.ToLower().Contains("silver")).Select(s => s.TypeCode).AsNoTracking().FirstOrDefaultAsync(); ;
                    transaction.Comments = "coupon redemption ... coupon id " + coupon.CouponId;
                    transaction.CoinAmount = calculated;
                    transaction.Timestamp = DateTime.Now;
                    transaction.TransactionID = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + userID;
                    transaction.UserGUID = userID;
                    transaction.TransactionType = await _context.TransactionTypes.AsQueryable().Where(c => c.TypeName.ToLower().Contains("silver credit")).Select(c => c.TypeCode).AsNoTracking().FirstOrDefaultAsync();
                    _context.UserTransactions.Add(transaction);

                    bool possible = await SilverBankOperations.WithdrawFromBank(calculated, _context);

                    if (!possible)
                        return StatusCode(500);
                }

                double price = double.Parse(coupon.Target.UnitPrice.Value.ToString());
                double worth = price - (price * bank.Worth.Value / 100);

                CouponRedemption redeemed = new CouponRedemption
                {
                    CountId = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + userID,
                    CouponId = coupon.CouponId,
                    Discount = bank.Worth,
                    UserGuid = userID,
                    Timestamp = DateTime.Now,
                    Worth = decimal.Parse(worth.ToString())

                };

                DailyVisit visit = await _context.DailyVisits.AsQueryable().Where(u => u.UserGuid == userID && u.Timestamp.Value.Month == DateTime.Now.Month &&
                  u.Timestamp.Value.Day == DateTime.Now.Day && u.Timestamp.Value.Year == DateTime.Now.Year).FirstOrDefaultAsync();

                if (visit == null)
                {
                    visit = new DailyVisit
                    {
                        BusinessId = coupon.BusinessId,
                        CountId = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + userID,
                        Timestamp = DateTime.Now,
                        UserGuid = userID
                    };

                    _context.DailyVisits.Add(visit);
                }

                _context.UserCouponBanks.Remove(bank);
                _context.CouponRedemptions.Add(redeemed);

                await _context.SaveChangesAsync();
                if (acquired.Mode == "gifted")
                {
                    DocumentReference docRef = db.Collection(ServerLocation.user_notifications).Document(acquiredMain.UserGuid).Collection(acquiredMain.UserGuid).Document();
                    Dictionary<string, object> user = new Dictionary<string, object>
                    {
                        { "notificationType", "gifted" },
                        { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                        { "message",  username + " redeemed a coupon you gifted them therefore you get silver coins back" },
                        { "couponID", coupon.CouponId },
                        { "productImage", coupon.Target.ProductImage },
                        { "recipient", acquiredMain.UserGuid },
                    };

                    DocumentReference docRef1 = db.Collection(ServerLocation.user_notifications).Document(userID).Collection(userID).Document();
                    Dictionary<string, object> user1 = new Dictionary<string, object>
                    {
                        { "notificationType", "redeemable" },
                        { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                        { "message", "You successfully redeemed a coupon" },
                        { "couponID", coupon.CouponId },
                        { "productImage", coupon.Target.ProductImage },
                    };

                    await docRef.SetAsync(user);
                    await docRef1.SetAsync(user1);
                }
                else
                {
                    DocumentReference docRef1 = db.Collection(ServerLocation.user_notifications).Document(userID).Collection(userID).Document();
                    Dictionary<string, object> user1 = new Dictionary<string, object>
                    {
                        { "notificationType", "redeemable" },
                        { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                        { "message", "You successfully redeemed a coupon" },
                        { "couponID", coupon.CouponId },
                        { "productImage", coupon.Target.ProductImage },
                    };

                    await docRef1.SetAsync(user1);
                }

                if (coupon.BusinessId == ServerLocation.tesoghanaID)
                {
                    string businessMessage = username + " just redeemed a coupon from the shop";
                    DocumentReference BusdocRef = db.Collection(ServerLocation.business_notifications).Document(coupon.Issuer.BusinessId).Collection(coupon.Issuer.BusinessId).Document();
                    Dictionary<string, object> Bususer = new Dictionary<string, object>
                    {
                        { "notificationType", "couponRedemption" },
                        { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                        { "message", businessMessage },
                        { "couponID", coupon.CouponId },
                        { "userID", userID},
                    };

                    string businessMessageTeso = username + " just redeemed a coupon at " + coupon.Issuer.BusinessName;
                    DocumentReference BusdocRef2 = db.Collection(ServerLocation.business_notifications).Document(coupon.BusinessId).Collection(coupon.BusinessId).Document();
                    Dictionary<string, object> Bususer2 = new Dictionary<string, object>
                    {
                        { "notificationType", "couponRedemption" },
                        { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                        { "message", businessMessageTeso },
                        { "couponID", coupon.CouponId },
                        { "userID", userID},
                    };
                    await BusdocRef2.SetAsync(Bususer2);
                    await BusdocRef.SetAsync(Bususer);
                }
                else
                {
                    string businessMessage = username + " just redeemed a coupon from the shop";
                    DocumentReference BusdocRef = db.Collection(ServerLocation.business_notifications).Document(coupon.Issuer.BusinessId).Collection(coupon.Issuer.BusinessId).Document();
                    Dictionary<string, object> Bususer = new Dictionary<string, object>
                    {
                        { "notificationType", "couponRedemption" },
                        { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                        { "message", businessMessage },
                        { "couponID", coupon.CouponId },
                        { "userID", userID},
                    };
                    await BusdocRef.SetAsync(Bususer);
                }
                return Ok(calculated);
            }
            catch (DbUpdateException)
            {
                return Conflict();
            }


        }

        [Authorize]
        [Route("acceptPersonalized"), HttpPost]
        public async Task<ActionResult> AcceptPerosnalizedCoupons(CouponsHead coupon)
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;
            string username = jwtToken.Claims.First(claim => claim.Type == "username").Value;

            string shopname = await _context.TesoBusinessDetails.AsQueryable().Where(i => i.BusinessId == coupon.BusinessId).Select(n => n.BusinessName).FirstOrDefaultAsync();
            Product product = await _context.Products.AsQueryable().Where(p => p.ProductId == coupon.TargetProduct).FirstOrDefaultAsync();
            DocumentReference deleteRef = db.Collection(ServerLocation.user_notifications).Document(userID).Collection(userID).Document(coupon.CouponId);
            if (coupon.Expiration > DateTime.Now)
            {
                CouponsHead couponsHead = new CouponsHead();
                couponsHead.BusinessId = coupon.BusinessId;
                couponsHead.CouponId = "TESCP" + String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 10000000) + coupon.BusinessId;
                couponsHead.Expiration = coupon.Expiration;
                couponsHead.Quantity = 1;
                couponsHead.State = "active";
                couponsHead.TargetProduct = coupon.TargetProduct;
                couponsHead.Type = coupon.Type;
                couponsHead.LowerLimit = coupon.LowerLimit;
                couponsHead.UpperLimit = coupon.UpperLimit;
                couponsHead.Generated = coupon.Generated;

                CouponCondition condition = new CouponCondition();
                condition.CouponId = couponsHead.CouponId;
                if (!String.IsNullOrEmpty(coupon.State))
                {
                    condition.Condition = coupon.State;
                }
                else
                {
                    condition.Condition = "none";
                }

                _context.CouponAcquisitions.Add(new CouponAcquisition
                {
                    CountId = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 100000000) + userID,
                    CouponId = couponsHead.CouponId,
                    Dateacquired = DateTime.Now,
                    Expiration = coupon.Expiration,
                    Mode = "personalized",
                    SilverCost = 0,
                    UserGuid = userID,
                    Worth = couponsHead.UpperLimit,
                });

                _context.UserCouponBanks.Add(new UserCouponBank
                {
                    CountId = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 100000000) + userID,
                    CouponId = couponsHead.CouponId,
                    Expiration = coupon.Expiration,
                    Worth = couponsHead.UpperLimit,
                    UserGuid = userID
                });

                _context.CouponsHeads.Add(couponsHead);
                _context.CouponConditions.Add(condition);

                try
                {
                    await _context.SaveChangesAsync();
                    DocumentReference docRef = db.Collection(ServerLocation.user_notifications).Document(userID).Collection(userID).Document();
                    Dictionary<string, object> user = new Dictionary<string, object>
                {
                    { "notificationType", "redeemable" },
                    { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                    { "message", $"Congrats you just accepted a personalized coupon from {shopname}" },
                    { "couponID", coupon.CouponId },
                    { "productImage", product.ProductImage },
                };

                    DocumentReference BusdocRef = db.Collection(ServerLocation.business_notifications).Document(product.BusinessId).Collection(product.BusinessId).Document();
                    Dictionary<string, object> Bususer = new Dictionary<string, object>
                {
                    { "notificationType", "couponAcquisition" },
                    { "timestamp", new DateTimeOffset(DateTimeOffset.UtcNow.DateTime).ToUnixTimeMilliseconds()},
                    { "message", $"{username} just accepted a personalized coupon you sent them!!" },
                    { "couponID", couponsHead.CouponId },
                    { "userID", userID},
                };
                    await docRef.SetAsync(user);
                    await deleteRef.DeleteAsync();
                    await BusdocRef.SetAsync(Bususer);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                    return StatusCode(500);
                }

                return Ok();
            }
            else
            {
                await deleteRef.DeleteAsync();
                return StatusCode(400);
            }
        }

        [Authorize]
        [Route("campaign_coupons"), HttpPost]
        public async Task<ActionResult<IEnumerable<CouponDetails>>> GetCampaignCoupons([FromBody] string campaignID)
        {
            var accessToken = Request.Headers[HeaderNames.Authorization];
            string token = accessToken;
            token = token.Substring(6).Trim();
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadToken(token) as JwtSecurityToken;
            string userID = jwtToken.Claims.First(claim => claim.Type == "userGUID").Value;

            List<CouponDetails> coupons = await (from c in _context.CouponsHeads.AsQueryable()
                                                 join ct in _context.CouponTypes on c.Type equals ct.TypeCode
                                                 join cam in _context.Campaigns on c.TargetProduct equals cam.TargetProduct into campaignList
                                                 from campaignItem in campaignList.DefaultIfEmpty()
                                                 join p in _context.Products on campaignItem.TargetProduct equals p.ProductId
                                                 join con in _context.CouponConditions on c.CouponId equals con.CouponId
                                                 where campaignItem.CampaignId == campaignID && c.Quantity > 0 && c.State == "active"
                                                 && (c.Type == "TESCP001" || c.Type == "TESCP002")
                                                 select new CouponDetails()
                                                 {
                                                     BusinessId = campaignItem.BusinessId,
                                                     condition = con.Condition,
                                                     countID = c.CouponId,
                                                     CouponId = c.CouponId,
                                                     Expiration = c.Expiration,
                                                     Issuer = _context.TesoBusinessDetails.AsQueryable().Where(b => b.BusinessId == campaignItem.BusinessId).FirstOrDefault(),
                                                     lowerLimit = c.LowerLimit,
                                                     ProductCost = p.ProductId,
                                                     Quantity = c.Quantity,
                                                     State = c.State,
                                                     Target = p,
                                                     Type = ct.TypeName,
                                                     upperLimit = c.UpperLimit,
                                                     Worth = 0

                                                 }
                                                 ).ToListAsync();

            return coupons;
        }
        private bool TrendingExists(string id)
        {
            return _context.TrendingProducts.Any(e => e.ProductId == id);
        }
    }
}