const {
  S3Client,
  PutObjectCommand,
  GetObjectCommand,
} = require("@aws-sdk/client-s3");
const fs = require("fs");
const path = require("path");
const https = require("https");
const { pipeline } = require("stream/promises");

const s3Client = new S3Client({
  region: "auto",
  endpoint: process.env.R2_ENDPOINT,
  credentials: {
    accessKeyId: process.env.R2_ACCESS_KEY_ID,
    secretAccessKey: process.env.R2_SECRET_ACCESS_KEY,
  },
});

const BUCKET = process.env.R2_BUCKET_NAME;
const PUBLIC_URL = process.env.R2_PUBLIC_URL;
const VERSION = process.env.RELEASE_VERSION;
const RELEASE_TAG = process.env.RELEASE_TAG || `v${VERSION}`;
const GITHUB_REPO = process.env.GITHUB_REPOSITORY;

async function fetchExistingReleases() {
  try {
    const response = await s3Client.send(
      new GetObjectCommand({
        Bucket: BUCKET,
        Key: "releases.json",
      })
    );
    const body = await response.Body.transformToString();
    return JSON.parse(body);
  } catch (error) {
    if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
      console.log("No existing releases.json found, creating new one");
      return { latestVersion: null, releases: [] };
    }
    throw error;
  }
}

async function uploadFile(localPath, r2Key, contentType) {
  const fileBuffer = fs.readFileSync(localPath);
  const stats = fs.statSync(localPath);

  await s3Client.send(
    new PutObjectCommand({
      Bucket: BUCKET,
      Key: r2Key,
      Body: fileBuffer,
      ContentType: contentType,
    })
  );

  console.log(`Uploaded: ${r2Key} (${stats.size} bytes)`);
  return stats.size;
}

function findArtifacts(dir, pattern) {
  if (!fs.existsSync(dir)) return [];
  const files = fs.readdirSync(dir);
  return files.filter((f) => pattern.test(f)).map((f) => path.join(dir, f));
}

async function checkUrlAccessible(url, maxRetries = 10, initialDelay = 1000) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const result = await new Promise((resolve, reject) => {
        const request = https.get(url, { timeout: 10000 }, (response) => {
          const statusCode = response.statusCode;

          // Follow redirects
          if (
            statusCode === 302 ||
            statusCode === 301 ||
            statusCode === 307 ||
            statusCode === 308
          ) {
            const redirectUrl = response.headers.location;
            response.destroy();
            if (!redirectUrl) {
              resolve({
                accessible: false,
                statusCode,
                error: "Redirect without location header",
              });
              return;
            }
            // Follow the redirect URL
            return https
              .get(redirectUrl, { timeout: 10000 }, (redirectResponse) => {
                const redirectStatus = redirectResponse.statusCode;
                const contentType =
                  redirectResponse.headers["content-type"] || "";
                // Check if it's actually a file (zip/tar.gz) and not HTML
                const isFile =
                  contentType.includes("application/zip") ||
                  contentType.includes("application/gzip") ||
                  contentType.includes("application/x-gzip") ||
                  contentType.includes("application/x-tar") ||
                  redirectUrl.includes(".zip") ||
                  redirectUrl.includes(".tar.gz");
                const isGood =
                  redirectStatus >= 200 && redirectStatus < 300 && isFile;
                redirectResponse.destroy();
                resolve({
                  accessible: isGood,
                  statusCode: redirectStatus,
                  finalUrl: redirectUrl,
                  contentType,
                });
              })
              .on("error", (error) => {
                resolve({
                  accessible: false,
                  statusCode,
                  error: error.message,
                });
              })
              .on("timeout", function () {
                this.destroy();
                resolve({
                  accessible: false,
                  statusCode,
                  error: "Timeout following redirect",
                });
              });
          }

          // Check if status is good (200-299 range) and it's actually a file
          const contentType = response.headers["content-type"] || "";
          const isFile =
            contentType.includes("application/zip") ||
            contentType.includes("application/gzip") ||
            contentType.includes("application/x-gzip") ||
            contentType.includes("application/x-tar") ||
            url.includes(".zip") ||
            url.includes(".tar.gz");
          const isGood = statusCode >= 200 && statusCode < 300 && isFile;
          response.destroy();
          resolve({ accessible: isGood, statusCode, contentType });
        });

        request.on("error", (error) => {
          resolve({
            accessible: false,
            statusCode: null,
            error: error.message,
          });
        });

        request.on("timeout", () => {
          request.destroy();
          resolve({
            accessible: false,
            statusCode: null,
            error: "Request timeout",
          });
        });
      });

      if (result.accessible) {
        if (attempt > 0) {
          console.log(
            `✓ URL ${url} is now accessible after ${attempt} retries (status: ${result.statusCode})`
          );
        } else {
          console.log(
            `✓ URL ${url} is accessible (status: ${result.statusCode})`
          );
        }
        return result.finalUrl || url; // Return the final URL (after redirects) if available
      } else {
        const errorMsg = result.error ? ` - ${result.error}` : "";
        const statusMsg = result.statusCode
          ? ` (status: ${result.statusCode})`
          : "";
        const contentTypeMsg = result.contentType
          ? ` [content-type: ${result.contentType}]`
          : "";
        console.log(
          `✗ URL ${url} not accessible${statusMsg}${contentTypeMsg}${errorMsg}`
        );
      }
    } catch (error) {
      console.log(`✗ URL ${url} check failed: ${error.message}`);
    }

    if (attempt < maxRetries - 1) {
      const delay = initialDelay * Math.pow(2, attempt);
      console.log(
        `  Retrying in ${delay}ms... (attempt ${attempt + 1}/${maxRetries})`
      );
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  throw new Error(`URL ${url} is not accessible after ${maxRetries} attempts`);
}

async function downloadFromGitHub(url, outputPath) {
  return new Promise((resolve, reject) => {
    const request = https.get(url, { timeout: 30000 }, (response) => {
      const statusCode = response.statusCode;

      // Follow redirects (all redirect types)
      if (
        statusCode === 301 ||
        statusCode === 302 ||
        statusCode === 307 ||
        statusCode === 308
      ) {
        const redirectUrl = response.headers.location;
        response.destroy();
        if (!redirectUrl) {
          reject(new Error(`Redirect without location header for ${url}`));
          return;
        }
        // Resolve relative redirects
        const finalRedirectUrl = redirectUrl.startsWith("http")
          ? redirectUrl
          : new URL(redirectUrl, url).href;
        console.log(`  Following redirect: ${finalRedirectUrl}`);
        return downloadFromGitHub(finalRedirectUrl, outputPath)
          .then(resolve)
          .catch(reject);
      }

      if (statusCode !== 200) {
        response.destroy();
        reject(
          new Error(
            `Failed to download ${url}: ${statusCode} ${response.statusMessage}`
          )
        );
        return;
      }

      const fileStream = fs.createWriteStream(outputPath);
      response.pipe(fileStream);
      fileStream.on("finish", () => {
        fileStream.close();
        resolve();
      });
      fileStream.on("error", (error) => {
        response.destroy();
        reject(error);
      });
    });

    request.on("error", reject);
    request.on("timeout", () => {
      request.destroy();
      reject(new Error(`Request timeout for ${url}`));
    });
  });
}

async function main() {
  const artifactsDir = "artifacts";
  const tempDir = path.join(artifactsDir, "temp");

  // Create temp directory for downloaded GitHub archives
  if (!fs.existsSync(tempDir)) {
    fs.mkdirSync(tempDir, { recursive: true });
  }

  // Download source archives from GitHub
  const githubZipUrl = `https://github.com/${GITHUB_REPO}/archive/refs/tags/${RELEASE_TAG}.zip`;
  const githubTarGzUrl = `https://github.com/${GITHUB_REPO}/archive/refs/tags/${RELEASE_TAG}.tar.gz`;

  const sourceZipPath = path.join(tempDir, `automaker-${VERSION}.zip`);
  const sourceTarGzPath = path.join(tempDir, `automaker-${VERSION}.tar.gz`);

  console.log(`Waiting for source archives to be available on GitHub...`);
  console.log(`  ZIP: ${githubZipUrl}`);
  console.log(`  TAR.GZ: ${githubTarGzUrl}`);

  // Wait for archives to be accessible with exponential backoff
  // This returns the final URL after following redirects
  const finalZipUrl = await checkUrlAccessible(githubZipUrl);
  const finalTarGzUrl = await checkUrlAccessible(githubTarGzUrl);

  console.log(`Downloading source archives from GitHub...`);
  await downloadFromGitHub(finalZipUrl, sourceZipPath);
  await downloadFromGitHub(finalTarGzUrl, sourceTarGzPath);

  console.log(`Downloaded source archives successfully`);

  // Find all artifacts
  const artifacts = {
    windows: findArtifacts(path.join(artifactsDir, "windows-builds"), /\.exe$/),
    macos: findArtifacts(path.join(artifactsDir, "macos-builds"), /-x64\.dmg$/),
    macosArm: findArtifacts(
      path.join(artifactsDir, "macos-builds"),
      /-arm64\.dmg$/
    ),
    linux: findArtifacts(
      path.join(artifactsDir, "linux-builds"),
      /\.AppImage$/
    ),
    sourceZip: [sourceZipPath],
    sourceTarGz: [sourceTarGzPath],
  };

  console.log("Found artifacts:");
  for (const [platform, files] of Object.entries(artifacts)) {
    console.log(
      `  ${platform}: ${
        files.length > 0
          ? files.map((f) => path.basename(f)).join(", ")
          : "none"
      }`
    );
  }

  // Upload each artifact to R2
  const assets = {};
  const contentTypes = {
    windows: "application/x-msdownload",
    macos: "application/x-apple-diskimage",
    macosArm: "application/x-apple-diskimage",
    linux: "application/x-executable",
    sourceZip: "application/zip",
    sourceTarGz: "application/gzip",
  };

  for (const [platform, files] of Object.entries(artifacts)) {
    if (files.length === 0) {
      console.warn(`Warning: No artifact found for ${platform}`);
      continue;
    }

    // Use the first matching file for each platform
    const localPath = files[0];
    const filename = path.basename(localPath);
    const r2Key = `releases/${VERSION}/${filename}`;
    const size = await uploadFile(localPath, r2Key, contentTypes[platform]);

    assets[platform] = {
      url: `${PUBLIC_URL}/releases/${VERSION}/${filename}`,
      filename,
      size,
      arch:
        platform === "macosArm"
          ? "arm64"
          : platform === "sourceZip" || platform === "sourceTarGz"
          ? "source"
          : "x64",
    };
  }

  // Fetch and update releases.json
  const releasesData = await fetchExistingReleases();

  const newRelease = {
    version: VERSION,
    date: new Date().toISOString(),
    assets,
    githubReleaseUrl: `https://github.com/${GITHUB_REPO}/releases/tag/${RELEASE_TAG}`,
  };

  // Remove existing entry for this version if re-running
  releasesData.releases = releasesData.releases.filter(
    (r) => r.version !== VERSION
  );

  // Prepend new release
  releasesData.releases.unshift(newRelease);
  releasesData.latestVersion = VERSION;

  // Upload updated releases.json
  await s3Client.send(
    new PutObjectCommand({
      Bucket: BUCKET,
      Key: "releases.json",
      Body: JSON.stringify(releasesData, null, 2),
      ContentType: "application/json",
      CacheControl: "public, max-age=60",
    })
  );

  console.log("Successfully updated releases.json");
  console.log(`Latest version: ${VERSION}`);
  console.log(`Total releases: ${releasesData.releases.length}`);
}

main().catch((err) => {
  console.error("Failed to upload to R2:", err);
  process.exit(1);
});