@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/auth/**").permitAll()
                .requestMatchers("/api/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        
        return http.build();
    }
    
    // Outros beans e configurações...
}

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {
        
        String token = extractTokenFromRequest(request);
        
        if (token != null && jwtService.validateToken(token)) {
            Authentication authentication = jwtService.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        
        filterChain.doFilter(request, response);
    }
    
    // Métodos auxiliares...
}

@Service
public class JwtService {
    
    @Value("${jwt.secret}")
    private String jwtSecret;
    
    @Value("${jwt.expiration}")
    private long jwtExpiration;
    
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        User user = (User) userDetails;
        
        claims.put("id", user.getId());
        claims.put("email", user.getEmail());
        claims.put("userType", user.getUserType());
        claims.put("subscriptionType", user.getSubscriptionType());
        
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(userDetails.getUsername())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + jwtExpiration))
                .signWith(SignatureAlgorithm.HS512, jwtSecret)
                .compact();
    }
    
    // Métodos para validação e extração de informações...
}

@Service
public class FirebaseAuthService {
    
    private final FirebaseAuth firebaseAuth;
    
    public FirebaseAuthService(FirebaseAuth firebaseAuth) {
        this.firebaseAuth = firebaseAuth;
    }
    
    public FirebaseToken verifyIdToken(String idToken) throws FirebaseAuthException {
        return firebaseAuth.verifyIdToken(idToken);
    }
    
    // Outros métodos relacionados ao Firebase Auth...
}

// Web (Next.js)
export const TOKEN_NAME = "fitlocus_auth_token";

export const setToken = (token: string) => {
  Cookies.set(TOKEN_NAME, token, { expires: 7, path: "/" });
};

export const getToken = () => {
  return Cookies.get(TOKEN_NAME);
};

export const removeToken = () => {
  Cookies.remove(TOKEN_NAME, { path: "/" });
};

// Mobile (React Native)
export const setToken = async (token: string) => {
  await AsyncStorage.setItem(TOKEN_NAME, token);
};

export const getToken = async () => {
  return await AsyncStorage.getItem(TOKEN_NAME);
};

export const removeToken = async () => {
  await AsyncStorage.removeItem(TOKEN_NAME);
};

export const AuthContext = createContext<AuthContextData>({} as AuthContextData);

export const AuthProvider = ({ children }: { children: React.ReactNode }) => {
  const [user, setUser] = useState<User | null>(null);
  const [loading, setLoading] = useState(true);
  
  useEffect(() => {
    const loadUser = async () => {
      const token = getToken();
      
      if (token) {
        try {
          const user = await authService.getAuthenticatedUser();
          setUser(user);
        } catch (error) {
          removeToken();
        }
      }
      
      setLoading(false);
    };
    
    loadUser();
  }, []);
  
  const login = async (credentials: LoginCredentials) => {
    const response = await authService.login(credentials);
    setToken(response.token);
    setUser(response);
    return response;
  };
  
  const register = async (userData: RegisterData) => {
    const response = await authService.register(userData);
    setToken(response.token);
    setUser(response);
    return response;
  };
  
  const loginWithGoogle = async (token: string, userType: string) => {
    const response = await authService.handleGoogleAuth(token, userType);
    setToken(response.token);
    setUser(response);
    return response;
  };
  
  const logout = () => {
    removeToken();
    setUser(null);
  };
  
  return (
    <AuthContext.Provider value={{ user, loading, login, logout, register, loginWithGoogle }}>
      {children}
    </AuthContext.Provider>
  );
};

export const useAuth = () => {
  const context = useContext(AuthContext);
  
  if (!context) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  
  return context;
};

export function middleware(request: NextRequest) {
  const token = request.cookies.get(TOKEN_NAME)?.value;
  const isAuthRoute = request.nextUrl.pathname.startsWith('/login') || 
                      request.nextUrl.pathname.startsWith('/registro');
  const isDashboardRoute = request.nextUrl.pathname.startsWith('/dashboard');
  
  if (!token && isDashboardRoute) {
    return NextResponse.redirect(new URL('/login', request.url));
  }
  
  if (token && isAuthRoute) {
    return NextResponse.redirect(new URL('/dashboard', request.url));
  }
  
  return NextResponse.next();
}

export const config = {
  matcher: ['/dashboard/:path*', '/login', '/registro'],
};

const ProtectedRoute = ({ children }: { children: React.ReactNode }) => {
  const { user, loading } = useAuth();
  const navigation = useNavigation();
  
  useEffect(() => {
    if (!loading && !user) {
      navigation.navigate('Login');
    }
  }, [user, loading, navigation]);
  
  if (loading) {
    return <LoadingScreen />;
  }
  
  return user ? <>{children}</> : null;
};

public enum EnumUserType {
    ALUNO,
    PERSONAL
}

public enum SubscriptionType {
    FREEMIUM,
    TRIAL,
    PREMIUM_MENSAL,
    PREMIUM_SEMESTRAL,
    PREMIUM_ANUAL,
    PERSONAL_INICIANTE,      // até 10
    PERSONAL_BASIC,          // até 50
    PERSONAL_INTERMEDIARIO,  // até 100
    PERSONAL_AVANCADO,       // até 200
    PERSONAL_ILIMITADO       // 201+
}

@Component
public class SubscriptionValidator {
    
    public boolean canAccessPremiumFeature(User user) {
        if (user.getSubscriptionType() == SubscriptionType.FREEMIUM) {
            return false;
        }
        
        if (user.getSubscriptionType() == SubscriptionType.TRIAL) {
            LocalDate trialStartDate = user.getTrialStartDate();
            LocalDate now = LocalDate.now();
            
            return trialStartDate != null && 
                   ChronoUnit.DAYS.between(trialStartDate, now) <= 7;
        }
        
        return true;
    }
    
    // Outros métodos de validação...
}

@Component
public class LoginAttemptService {
    
    private final LoadingCache<String, Integer> attemptsCache;
    
    public LoginAttemptService() {
        attemptsCache = CacheBuilder.newBuilder()
                .expireAfterWrite(1, TimeUnit.DAYS)
                .build(new CacheLoader<String, Integer>() {
                    @Override
                    public Integer load(String key) {
                        return 0;
                    }
                });
    }
    
    public void loginSucceeded(String key) {
        attemptsCache.invalidate(key);
    }
    
    public void loginFailed(String key) {
        int attempts = 0;
        try {
            attempts = attemptsCache.get(key);
        } catch (ExecutionException e) {
            attempts = 0;
        }
        attempts++;
        attemptsCache.put(key, attempts);
    }
    
    public boolean isBlocked(String key) {
        try {
            return attemptsCache.get(key) >= 5;
        } catch (ExecutionException e) {
            return false;
        }
    }
}