import { describe, expect, it } from "vitest";
import {
  createRateLimitConfig,
  determineRateLimit,
  MANAGEMENT_API_DEFAULT_RATE_LIMIT,
  parseRateLimitHeaders,
} from "./rateLimit";
import { StoryblokContentVersion } from "./constants";
import type { ISbStoriesParams } from "./interfaces";

describe("rateLimit", () => {
  describe("createRateLimitConfig", () => {
    it("should create config with user rate limit", () => {
      const config = createRateLimitConfig(50);
      expect(config.userRateLimit).toBe(50);
      expect(config.serverHeadersRateLimit).toBeUndefined();
    });

    it("should create config without user rate limit", () => {
      const config = createRateLimitConfig();
      expect(config.userRateLimit).toBeUndefined();
      expect(config.serverHeadersRateLimit).toBeUndefined();
    });
  });

  describe("parseRateLimitHeaders", () => {
    it("should parse both X-RateLimit and X-RateLimit-Policy headers", () => {
      const headers = {
        "x-ratelimit": '"concurrent-requests";r=29',
        "x-ratelimit-policy": '"concurrent-requests";q=30',
      };
      const result = parseRateLimitHeaders(headers);
      expect(result).toEqual({
        remaining: 29,
        max: 30,
      });
    });

    it("should handle case-sensitive header names", () => {
      const headers = {
        "X-RateLimit": '"concurrent-requests";r=15',
        "X-RateLimit-Policy": '"concurrent-requests";q=50',
      };
      const result = parseRateLimitHeaders(headers);
      expect(result).toEqual({
        remaining: 15,
        max: 50,
      });
    });

    it("should parse only X-RateLimit header when present", () => {
      const headers = {
        "x-ratelimit": '"concurrent-requests";r=10',
      };
      const result = parseRateLimitHeaders(headers);
      expect(result).toEqual({
        remaining: 10,
      });
    });

    it("should parse only X-RateLimit-Policy header when present", () => {
      const headers = {
        "x-ratelimit-policy": '"concurrent-requests";q=100',
      };
      const result = parseRateLimitHeaders(headers);
      expect(result).toEqual({
        max: 100,
      });
    });

    it("should return null when no rate limit headers present", () => {
      const headers = {
        "content-type": "application/json",
      };
      const result = parseRateLimitHeaders(headers);
      expect(result).toBeNull();
    });

    it("should return null when headers is null or undefined", () => {
      expect(parseRateLimitHeaders(null)).toBeNull();
      expect(parseRateLimitHeaders(undefined)).toBeNull();
    });

    it("should handle malformed header values", () => {
      const headers = {
        "x-ratelimit": "invalid-format",
        "x-ratelimit-policy": "also-invalid",
      };
      const result = parseRateLimitHeaders(headers);
      expect(result).toBeNull();
    });
  });

  describe("determineRateLimit", () => {
    describe("precedence order", () => {
      it("should prefer user rate limit over server rate limit", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
        };
        const config = {
          userRateLimit: 25,
          serverHeadersRateLimit: 100,
        };
        const result = determineRateLimit("/cdn/stories", params, config);
        expect(result).toBe(25);
      });

      it("should prefer user rate limit over automatic tier calculation", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 100, // Would normally be 6 req/s
        };
        const config = {
          userRateLimit: 20,
        };
        const result = determineRateLimit("/cdn/stories", params, config);
        expect(result).toBe(20);
      });

      it("should use server rate limit when no user rate limit provided", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
        };
        const config = {
          serverHeadersRateLimit: 75,
        };
        const result = determineRateLimit("/cdn/stories", params, config);
        expect(result).toBe(75);
      });

      it("should cap any rate limit at 1000", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
        };

        // User rate limit capped at 1000
        const userConfig = {
          userRateLimit: 2000,
        };
        expect(determineRateLimit("/cdn/stories", params, userConfig)).toBe(1000);

        // Server headers rate limit capped at 1000
        const serverConfig = {
          serverHeadersRateLimit: 5000,
        };
        expect(determineRateLimit("/cdn/stories", params, serverConfig)).toBe(1000);
      });
    });

    describe("published requests (same rate limits as draft)", () => {
      it("should use per_page-based rate limit for published version", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.PUBLISHED,
        };
        // Default per_page is 25, so rate limit should be 50
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(50);
      });

      it("should use per_page-based rate limit when version is not specified", () => {
        const params: ISbStoriesParams = {};
        // Default per_page is 25, so rate limit should be 50
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(50);
      });

      it("should use 6 req/s for published with per_page 100", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.PUBLISHED,
          per_page: 100,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(6);
      });

      it("should apply user rate limit to published version", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.PUBLISHED,
        };
        const config = {
          userRateLimit: 50,
        };
        const result = determineRateLimit("/cdn/stories", params, config);
        expect(result).toBe(50);
      });

      it("should apply server rate limit to published version when no user limit", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.PUBLISHED,
        };
        const config = {
          serverHeadersRateLimit: 75,
        };
        const result = determineRateLimit("/cdn/stories", params, config);
        expect(result).toBe(75);
      });

      it("should prefer user rate limit over per_page-based limit for published", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.PUBLISHED,
          per_page: 100, // Would be 6 req/s
        };
        const config = {
          userRateLimit: 10,
          serverHeadersRateLimit: 100,
        };
        const result = determineRateLimit("/cdn/stories", params, config);
        expect(result).toBe(10);
      });
    });

    describe("server rate limit without user override", () => {
      it("should use server rate limit when provided and no user rate limit", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 100, // Would normally be 6 req/s
        };
        const config = {
          serverHeadersRateLimit: 30,
        };
        const result = determineRateLimit("/cdn/stories", params, config);
        expect(result).toBe(30);
      });
    });

    describe("uncached requests - single stories", () => {
      it("should use 50 req/s for single story by path", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
        };
        const result = determineRateLimit("/cdn/stories/home", params);
        expect(result).toBe(50);
      });

      it("should use 50 req/s for single story with find_by", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
        };
        // find_by is in ISbStoryParams, not ISbStoriesParams, but the logic still applies
        const result = determineRateLimit("/cdn/stories/some-uuid", params);
        expect(result).toBe(50);
      });
    });

    describe("uncached requests - listings by per_page", () => {
      it("should use 50 req/s for listings with per_page <= 25", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 10,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(50);
      });

      it("should use 50 req/s for listings with per_page = 25", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 25,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(50);
      });

      it("should use 50 req/s for listings without per_page (defaults to 25)", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(50);
      });

      it("should use 15 req/s for listings with per_page 26-50", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 26,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(15);
      });

      it("should use 15 req/s for listings with per_page = 50", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 50,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(15);
      });

      it("should use 10 req/s for listings with per_page 51-75", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 60,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(10);
      });

      it("should use 10 req/s for listings with per_page = 75", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 75,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(10);
      });

      it("should use 6 req/s for listings with per_page 76-100", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 80,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(6);
      });

      it("should use 6 req/s for listings with per_page = 100", () => {
        const params: ISbStoriesParams = {
          version: StoryblokContentVersion.DRAFT,
          per_page: 100,
        };
        const result = determineRateLimit("/cdn/stories", params);
        expect(result).toBe(6);
      });
    });
  });

  describe("management API rate limiting", () => {
    it("should use default 3 req/s when no config provided", () => {
      const result = determineRateLimit(
        undefined,
        undefined,
        {},
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );
      expect(result).toBe(MANAGEMENT_API_DEFAULT_RATE_LIMIT);
    });

    it("should use default 3 req/s for Management API with empty config", () => {
      const config = {
        isManagementApi: true,
      };
      const result = determineRateLimit(
        undefined,
        undefined,
        config,
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );
      expect(result).toBe(MANAGEMENT_API_DEFAULT_RATE_LIMIT);
    });

    it("should respect user rate limit over default", () => {
      const config = {
        userRateLimit: 10,
        isManagementApi: true,
      };
      const result = determineRateLimit(
        undefined,
        undefined,
        config,
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );
      expect(result).toBe(10);
    });

    it("should respect server rate limit when no user override", () => {
      const config = {
        serverHeadersRateLimit: 50,
        isManagementApi: true,
      };
      const result = determineRateLimit(
        undefined,
        undefined,
        config,
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );
      expect(result).toBe(50);
    });

    it("should prioritize user rate limit over server rate limit", () => {
      const config = {
        userRateLimit: 15,
        serverHeadersRateLimit: 50,
        isManagementApi: true,
      };
      const result = determineRateLimit(
        undefined,
        undefined,
        config,
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );
      expect(result).toBe(15);
    });

    it("should cap user rate limit at 1000", () => {
      const config = {
        userRateLimit: 5000,
        isManagementApi: true,
      };
      const result = determineRateLimit(
        undefined,
        undefined,
        config,
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );
      expect(result).toBe(1000);
    });

    it("should cap server rate limit at 1000", () => {
      const config = {
        serverHeadersRateLimit: 2000,
        isManagementApi: true,
      };
      const result = determineRateLimit(
        undefined,
        undefined,
        config,
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );
      expect(result).toBe(1000);
    });

    it("should follow precedence: user > server > default (3)", () => {
      // Only default
      expect(determineRateLimit(undefined, undefined, {}, MANAGEMENT_API_DEFAULT_RATE_LIMIT)).toBe(
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );

      // Server override
      expect(
        determineRateLimit(
          undefined,
          undefined,
          { serverHeadersRateLimit: 25 },
          MANAGEMENT_API_DEFAULT_RATE_LIMIT,
        ),
      ).toBe(25);

      // User overrides everything
      expect(
        determineRateLimit(
          undefined,
          undefined,
          {
            userRateLimit: 10,
            serverHeadersRateLimit: 25,
          },
          MANAGEMENT_API_DEFAULT_RATE_LIMIT,
        ),
      ).toBe(10);
    });

    it("should use default rate limit of 3 for MAPI requests with params (regression test)", () => {
      // This tests the bug fix where MAPI requests with params were incorrectly
      // getting rate limit 1000 instead of 3 because they were treated as "cached" requests
      const params: ISbStoriesParams = {};
      const config = {
        isManagementApi: true,
      };

      // MAPI request with empty params should use default rate limit (3)
      const result = determineRateLimit(
        undefined,
        params,
        config,
        MANAGEMENT_API_DEFAULT_RATE_LIMIT,
      );
      expect(result).toBe(MANAGEMENT_API_DEFAULT_RATE_LIMIT);
      expect(result).toBe(3);
    });

    it("should use default rate limit of 3 for MAPI single story request", () => {
      // Simulates: getMapiClient.get(`spaces/{SPACE_ID}/stories/{STORY_ID}`)
      const url = "/spaces/123/stories/456";
      const params: ISbStoriesParams = {};
      const config = {
        isManagementApi: true,
      };

      // Should use MAPI default (3), not CDN cached rate limit (1000)
      const result = determineRateLimit(url, params, config, MANAGEMENT_API_DEFAULT_RATE_LIMIT);
      expect(result).toBe(3);
    });
  });
});