// @ts-check
/** @typedef {import('./_types.js').Provider} Provider */

// Glints provider — hits the public GraphQL v2-alc endpoint.
//
// Glints (glints.com) covers Singapore, Indonesia, Malaysia, and Vietnam.
// Their internal API is a no-auth GraphQL endpoint at /api/v2-alc/graphql that
// powers the job search page. The schema is reverse-engineered and may change.
//
// This provider is designed for explicit `provider: glints` in portals.yml.
// Auto-detection is not supported — Glints is a job board aggregator, not
// a company ATS.
//
// Portal entry fields (all optional except `provider`):
//   api             — GraphQL endpoint URL (default: https://glints.com/api/v2-alc/graphql)
//   searchKeywords  — Search keywords string (default: '')
//   countryCode     — Two-letter country code (default: "ID" for Indonesia)
//   pageSize        — Results per page (default: 30)
//   maxPages        — Maximum pages (default: 3)
//   graphqlQuery    — Custom GraphQL query string. If not provided, the
//                     built-in default query is used.

const DEFAULT_API = 'https://glints.com/api/v2-alc/graphql';
const DEFAULT_COUNTRY = 'ID';
const DEFAULT_PAGE_SIZE = 30;
const DEFAULT_MAX_PAGES = 3;

const ALLOWED_GLINTS_HOSTS = new Set([
  'glints.com',
  'www.glints.com',
  'glints.id',
]);

// Default GraphQL query — reverse-engineered from glints.com/id search.
// Uses the searchJobsV3 operation which replaced the older opportunities query.
const DEFAULT_GRAPHQL_QUERY = `
query searchJobsV3($data: JobSearchConditionInput!) {
  searchJobsV3(data: $data) {
    jobsInPage {
      id
      title
      company {
        name
        brandName
      }
      city {
        name
      }
      country {
        code
        name
      }
      salaries {
        salaryType
        salaryMode
        maxAmount
        minAmount
        CurrencyCode
      }
      createdAt
    }
    expInfo
    hasMore
  }
}`;

/** @param {string} url */
function assertGlintsUrl(url) {
  let parsed;
  try {
    parsed = new URL(url);
  } catch {
    throw new Error(`glints: invalid URL: ${url}`);
  }
  if (parsed.protocol !== 'https:') throw new Error(`glints: URL must use HTTPS: ${url}`);
  if (!ALLOWED_GLINTS_HOSTS.has(parsed.hostname))
    throw new Error(`glints: untrusted hostname "${parsed.hostname}" — must be one of: ${[...ALLOWED_GLINTS_HOSTS].join(', ')}`);
  return url;
}

// NaN-safe Date.parse
function toEpochMs(value) {
  if (!value) return undefined;
  const parsed = Date.parse(value);
  return Number.isNaN(parsed) ? undefined : parsed;
}

/**
 * Derive the job detail base URL from the API hostname.
 * @param {string} apiUrl
 * @returns {string}
 */
function deriveBaseUrl(apiUrl) {
  try {
    const parsed = new URL(apiUrl);
    return `${parsed.protocol}//${parsed.hostname}`;
  } catch {
    return 'https://glints.com';
  }
}

/**
 * Parse a single Glints job (searchJobsV3 response) into the canonical Job shape.
 *
 * This parser is exported as a named export for unit tests.
 *
 * @param {any} item — raw GraphQL result item from searchJobsV3
 * @param {string} baseUrl — scheme + hostname for resolving relative URLs
 * @param {string} fallbackCompany — company name fallback from portal entry
 * @returns {{title: string, url: string, company: string, location: string, postedAt: number|undefined}|null}
 */
export function parseGlintsItem(item, baseUrl, fallbackCompany) {
  if (!item || typeof item !== 'object') return null;

  const title = (item.title || '').trim();
  if (!title) return null;

  // Build job URL from the job ID
  const jobId = (item.id || '').trim();
  if (!jobId) return null;
  const url = `${baseUrl}/id/opportunities/jobs/${jobId}`;

  // Validate URL hostname
  try {
    const parsed = new URL(url);
    const hostname = parsed.hostname;
    const allowed = ALLOWED_GLINTS_HOSTS.has(hostname) || hostname.endsWith('.glints.com');
    if (!allowed) return null;
  } catch {
    return null;
  }

  const company = (item.company?.name || item.company?.brandName || fallbackCompany || '').trim();
  const location = (item.city?.name || '').trim();
  const postedAt = toEpochMs(item.createdAt);

  return { title, url, company, location, ...(postedAt != null ? { postedAt } : {}) };
}

/**
 * Execute a single GraphQL query page.
 * @param {string} apiUrl
 * @param {string} query
 * @param {object} variables
 * @param {import('./_types.js').Context} ctx
 * @returns {Promise<any>}
 */
async function graphqlPage(apiUrl, query, variables, ctx) {
  const body = JSON.stringify({ operationName: 'searchJobsV3', query, variables });
  // Glints firewall blocks non-browser User-Agents, so use a real Chrome UA
  try {
    const res = await ctx.fetchJson(apiUrl, {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
        'origin': 'https://glints.com',
        'referer': 'https://glints.com/id/opportunities/jobs/explore',
      },
      body,
      redirect: 'error',
    });
    return res;
  } catch (err) {
    // On POST, some servers return non-JSON errors; attempt text fallback
    if (err.status && err.body) {
      let detail = '';
      try {
        const parsed = JSON.parse(err.body);
        detail = parsed.errors?.[0]?.message || err.body.slice(0, 200);
      } catch {
        detail = err.body.slice(0, 200);
      }
      throw new Error(`glints: HTTP ${err.status} — ${detail}`);
    }
    throw err;
  }
}

/** @type {Provider} */
export default {
  id: 'glints',

  detect(_entry) {
    // Glints is a job board aggregator, not a company ATS.
    // Auto-detection is intentionally not supported —
    // use `provider: glints` explicitly in portals.yml.
    return null;
  },

  async fetch(entry, ctx) {
    const apiUrl = entry.api || DEFAULT_API;
    assertGlintsUrl(apiUrl);
    const baseUrl = deriveBaseUrl(apiUrl);

    const query = entry.graphqlQuery || DEFAULT_GRAPHQL_QUERY;
    const keywords = entry.searchKeywords || '';
    const country = entry.countryCode || DEFAULT_COUNTRY;
    const pageSize = Number(entry.pageSize) || DEFAULT_PAGE_SIZE;
    const maxPages = Number(entry.maxPages) || DEFAULT_MAX_PAGES;
    const fallbackCompany = entry.name || '';

    const allJobs = [];

    for (let page = 1; page <= maxPages; page++) {
      const variables = {
        data: {
          SearchTerm: keywords,
          CountryCode: country,
          includeExternalJobs: true,
          pageSize: pageSize,
          page: page,
        },
      };

      let json;
      try {
        json = /** @type {any} */ (await graphqlPage(apiUrl, query, variables, ctx));
      } catch (err) {
        if (page === 1) throw err;
        console.error(`glints: page ${page} fetch failed — ${err.message}`);
        break;
      }

      const jobsInPage = json?.data?.searchJobsV3?.jobsInPage;
      if (!Array.isArray(jobsInPage)) {
        if (page === 1) throw new Error(`glints: unexpected API response — ${JSON.stringify(json).slice(0, 200)}`);
        break;
      }

      if (jobsInPage.length === 0) break;

      for (const item of jobsInPage) {
        const job = parseGlintsItem(item, baseUrl, fallbackCompany);
        if (job) allJobs.push(job);
      }

      // Stop if no more pages
      if (json?.data?.searchJobsV3?.hasMore === false) break;
      if (jobsInPage.length < pageSize) break;

      // Rate-limit courtesy delay
      await new Promise(resolve => setTimeout(resolve, 300));
    }

    return allJobs;
  },
};