package com.billpaymentservice.bbps.config;

import java.security.Key;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
import java.util.Base64;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Service;

import com.billpaymentservice.bbps.util.BBPSConstant;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;

@Service
public class JwtUtil {

	@Value("${jwt.secret}")
	private String secret;

	private final Map<String, Date> tokenBlacklist = new HashMap<>();

	private Key getSigningKey() {
		byte[] keyBytes = Decoders.BASE64.decode(secret);
		return Keys.hmacShaKeyFor(keyBytes);
	}

	public String generateToken(String username, String mid) {
		Map<String, Object> claims = new HashMap<>();
		claims.put("mid", mid);
		claims.put("expiryTime", new Date(System.currentTimeMillis() + BBPSConstant.JWT_EXPIRATION_MS).toString());
		return createToken(claims, username.toUpperCase());
	}

	public String doGenerateRefreshToken(Map<String, Object> claims, String subject) {
		return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
				.setExpiration(new Date(System.currentTimeMillis() + BBPSConstant.REFRESH_EXPIRATION_MS))
				.signWith(getSigningKey(), SignatureAlgorithm.HS512).compact();
	}

	public String extractUsername(String token) {
		return extractClaim(token, Claims::getSubject);
	}

	public Date extractExpiration(String token) {
		return extractClaim(token, Claims::getExpiration);
	}

	public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
		final Claims claims = extractAllClaims(token);
		return claimsResolver.apply(claims);
	}

	private Claims extractAllClaims(String token) {
		return Jwts.parserBuilder().setSigningKey(getSigningKey()).build().parseClaimsJws(token).getBody();
	}

	private Boolean isTokenExpired(String token) {
		return extractExpiration(token).before(new Date());
	}

	private String createToken(Map<String, Object> claims, String subject) {
		return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
				.setExpiration(new Date(System.currentTimeMillis() + BBPSConstant.JWT_TEMPERARY_EXPIRATION_MS))
				.signWith(getSigningKey(), SignatureAlgorithm.HS512).compact();
	}

	private String createToken1(Map<String, Object> claims, String subject) {
		return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
				.setExpiration(new Date(System.currentTimeMillis() + BBPSConstant.JWT_EXPIRATION_MS))
				.signWith(getSigningKey(), SignatureAlgorithm.HS512).compact();
	}

//	public Boolean validateToken(String token, UserDetails userDetails) {
//		final String username = extractUsername(token);
//		return true;
//	}

	public Boolean validateToken(String token, UserDetails userDetails) {
		final String mobileNo = extractUsername(token);
//		System.out.println("Extracted mobileNo  from token: " + mobileNo );
//		System.out.println("Username from UserDetails: " + userDetails.getUsername());
		return (mobileNo.equals(userDetails.getUsername()) && !isTokenExpired(token));
	}

	public void invalidateToken(String token) {
		tokenBlacklist.put(token, new Date());
	}

	public boolean isTokenBlacklisted(String token) {
		Date invalidationTime = tokenBlacklist.get(token);
		return invalidationTime != null && invalidationTime.before(new Date());
	}

	public String generateToken(String mobileNo) {
		Map<String, Object> claims = new HashMap<>();
		claims.put("mobileNo", mobileNo);
		return createToken1(claims, mobileNo);
	}

	public String generateTemperaryToken(String mobileNo) {
		Map<String, Object> claims = new HashMap<>();
		long currentTime = System.currentTimeMillis();
		SimpleDateFormat sdf = new SimpleDateFormat("hh:mm a dd/MM/yyyy");
		String formattedDate = sdf.format(new Date(currentTime));
		claims.put("mobileNo", mobileNo);
		claims.put("timestamp", formattedDate);
		return createToken(claims, mobileNo);
	}

	public Claims parseToken(String token) {
		byte[] decodedKey = Base64.getDecoder().decode(secret);
		Key key = Keys.hmacShaKeyFor(decodedKey); // Generate the key

		return Jwts.parserBuilder() // Use parserBuilder() instead of parser() as it's more modern
				.setSigningKey(key) // Use the Key object
				.build() // Build the JwtParser
				.parseClaimsJws(token) // Parse the JWT
				.getBody(); // Return claims
	}

}