/**
 * ------------------------------------------------------------
 * 🧩 Brain Data Downloader (Pure Node.js)
 * ------------------------------------------------------------
 * Fetches brain data list from the HiNeuron API,
 * saves it as data.txt, then downloads all related
 * .tif and .swc files automatically.
 *
 * ✅ Requirements (Before You Run):
 *    1️⃣ Make sure you have Node.js version 18 or higher installed.
 *        👉 Check with:  node -v
 *    2️⃣ This script runs in Node.js directly (no browser).
 *    3️⃣ Internet access required.
 *
 * ------------------------------------------------------------
 * Run example:
 *    node brain_data_downloader.js
 * ------------------------------------------------------------
 */

import fs from "fs";
import https from "https";
import path from "path";

/**
 * Download a single file via HTTPS
 * @param {string} fileUrl - File download URL
 * @param {string} saveTo - Full path to save file
 */
function downloadFile(fileUrl, saveTo) {
  return new Promise((resolve) => {
    console.log("Downloading:", fileUrl);

    https
      .get(fileUrl, (res) => {
        if (res.statusCode !== 200) {
          console.error(`❌ Failed: ${fileUrl} (HTTP ${res.statusCode})`);
          res.resume(); // Avoid memory leak
          return resolve(false);
        }

        const dir = path.dirname(saveTo);
        fs.mkdirSync(dir, { recursive: true });
        const fileStream = fs.createWriteStream(saveTo);
        res.pipe(fileStream);
        fileStream.on("finish", () => {
          fileStream.close();
          console.log("✅ Saved:", path.basename(saveTo));
          resolve(true);
        });
      })
      .on("error", (err) => {
        console.error("❌ Error:", err.message);
        resolve(false);
      });
  });
}

/**
 * Download brain data resources from HiNeuron API
 * @param {number} dataCount - Number of brain regions
 * @param {number} taskLevel - Task difficulty level
 * @param {string} savePath - Local directory to save files
 */
async function downloadBrainData(dataCount, taskLevel, savePath) {
  try {
    const apiUrl = `https://atlas.brainsmatics.cn/program/frontend/HiNeuron?dataCount=${dataCount}&taskLevel=${taskLevel}`;
    console.log("Fetching data.txt from:", apiUrl);

    // Fetch data.txt content
    const dataTxt = await new Promise((resolve, reject) => {
      https
        .get(apiUrl, (res) => {
          if (res.statusCode !== 200) {
            return reject(new Error(`HTTP ${res.statusCode}`));
          }

          let data = "";
          res.on("data", (chunk) => (data += chunk));
          res.on("end", () => resolve(data));
        })
        .on("error", reject);
    });

    // Save data.txt locally
    fs.mkdirSync(savePath, { recursive: true });
    const dataFile = path.join(savePath, "data.txt");
    fs.writeFileSync(dataFile, dataTxt, "utf-8");
    console.log("✅ Saved data.txt:", dataFile);

    // Parse lines
    const lines = dataTxt
      .split(/\r?\n/)
      .map((l) => l.trim())
      .filter((l) => l);
    console.log(`Found ${lines.length} entries in data.txt`);

    // Download each pair (.tif + .swc)
    for (const line of lines) {
      const bracketIndex = line.indexOf("(");
      if (bracketIndex === -1) continue;
      const idPart = line.substring(0, bracketIndex);
      const parts = idPart.split("_");
      if (parts.length < 3) continue;

      const [brainNum, neuronNum, imageNum] = parts;

      const tifUrl = `https://atlas.brainsmatics.cn/HiNeuron1/${brainNum}/${neuronNum}/3D/image/${imageNum}.tif`;
      const swcUrl = `https://atlas.brainsmatics.cn/HiNeuron1/${brainNum}/${neuronNum}/3D/swc/${imageNum}.swc`;

      await downloadFile(tifUrl, path.join(savePath, `${idPart}.tif`));
      await downloadFile(swcUrl, path.join(savePath, `${idPart}.swc`));
    }

    console.log("✅ All files downloaded successfully to:", savePath);
  } catch (err) {
    console.error("❌ Error:", err.message);
  }
}

// Example usage
downloadBrainData(10, 2, "C:/opt/file2");

import requests
from pathlib import Path

def download_file(url: str, save_to: Path):
    print(f"Downloading: {url}")
    try:
        response = requests.get(url, timeout=30)
        if response.status_code != 200:
            print(f"❌ Failed: {url} (HTTP {response.status_code})")
            return False

        save_to.parent.mkdir(parents=True, exist_ok=True)
        with open(save_to, "wb") as f:
            f.write(response.content)

        print(f"✅ Saved: {save_to.name}")
        return True
    except Exception as e:
        print(f"❌ Error downloading {url}: {e}")
        return False


def download_brain_data(data_count: int, task_level: int, save_path: str):
    try:
        api_url = f"https://atlas.brainsmatics.cn/program/frontend/HiNeuron?dataCount={data_count}&taskLevel={task_level}"
        print(f"Fetching data.txt from: {api_url}")
        resp = requests.get(api_url)
        if resp.status_code != 200:
            print(f"HTTP request failed: {resp.status_code}")
            return False

        save_dir = Path(save_path)
        save_dir.mkdir(parents=True, exist_ok=True)
        data_txt_path = save_dir / "data.txt"
        data_txt_path.write_text(resp.text, encoding="utf-8")

        lines = [line.strip() for line in resp.text.splitlines() if line.strip()]
        print(f"Found {len(lines)} entries in data.txt")

        for line in lines:
            if "(" not in line:
                continue
            id_part = line.split("(")[0]
            parts = id_part.split("_")
            if len(parts) < 3:
                print(f"Invalid line format: {line}")
                continue

            brain_num, neuron_num, image_num = parts
            tif_url = f"https://atlas.brainsmatics.cn/HiNeuron1/{brain_num}/{neuron_num}/3D/image/{image_num}.tif"
            swc_url = f"https://atlas.brainsmatics.cn/HiNeuron1/{brain_num}/{neuron_num}/3D/swc/{image_num}.swc"

            download_file(tif_url, save_dir / f"{id_part}.tif")
            download_file(swc_url, save_dir / f"{id_part}.swc")

        print(f"✅ All files downloaded successfully to: {save_path}")
        return True
    except Exception as e:
        print(f"❌ Error: {e}")
        return False


# 示例调用
if __name__ == "__main__":
    download_brain_data(10, 2, "C:/opt/file")

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.List;

public class BrainDataDownloader {

	/**
	 * Download brain data resources based on data.txt content
	 *
	 * @param dataCount Number of brain regions
	 * @param taskLevel Task difficulty level
	 * @param savePath  Local directory to save files
	 * @return Whether download was successful
	 */
	public static boolean downloadBrainData(int dataCount, int taskLevel, String savePath) {
		try {
			// Build API URL
			String apiUrl = String.format(
					"https://atlas.brainsmatics.cn/program/frontend/HiNeuron?dataCount=%d&taskLevel=%d", dataCount,
					taskLevel);

			System.out.println("Fetching brain_data.txt from API...");
			URL url = new URL(apiUrl);
			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
			connection.setRequestMethod("GET");

			if (connection.getResponseCode() != HttpURLConnection.HTTP_OK) {
				System.err.println("HTTP request failed: " + connection.getResponseCode());
				return false;
			}

			// Save the downloaded data.txt
			Path tempPath = Paths.get(savePath, "data.txt");
			Files.createDirectories(tempPath.getParent());
			try (InputStream in = connection.getInputStream()) {
				Files.copy(in, tempPath, StandardCopyOption.REPLACE_EXISTING);
			}
			connection.disconnect();

			// Read data.txt lines
			List lines = Files.readAllLines(tempPath);
			lines.removeIf(String::isEmpty);
			System.out.println("Found " + lines.size() + " entries in data.txt");

			// Download resources for each entry
			for (int i = 0; i < lines.size(); i++) {
				String line = lines.get(i).trim();
				int bracketIndex = line.indexOf('(');
				if (bracketIndex == -1)
					continue;

				// Extract prefix before '('
				String idPart = line.substring(0, bracketIndex); // e.g., 231488_61_1236
				String[] parts = idPart.split("_");
				if (parts.length < 3) {
					System.err.println("Invalid line format: " + line);
					continue;
				}

				String brainNum = parts[0];
				String neuronNum = parts[1];
				String imageNum = parts[2];

				// Construct URLs
				String tifUrl = String.format("https://atlas.brainsmatics.cn/HiNeuron1/%s/%s/3D/image/%s.tif", brainNum,
						neuronNum, imageNum);
				String swcUrl = String.format("https://atlas.brainsmatics.cn/HiNeuron1/%s/%s/3D/swc/%s.swc", brainNum,
						neuronNum, imageNum);

				// Download both files
				downloadFile(tifUrl, Paths.get(savePath, idPart + ".tif"));
				downloadFile(swcUrl, Paths.get(savePath, idPart + ".swc"));
			}

			System.out.println("✅ All files downloaded successfully to: " + savePath);
			return true;

		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	private static void downloadFile(String fileUrl, Path saveTo) {
		try {
			System.out.println("Downloading: " + fileUrl);
			URL url = new URL(fileUrl);
			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
			conn.setRequestMethod("GET");

			if (conn.getResponseCode() != HttpURLConnection.HTTP_OK) {
				System.err.println("❌ Failed: " + fileUrl + " (HTTP " + conn.getResponseCode() + ")");
				conn.disconnect();
				return;
			}

			try (InputStream in = conn.getInputStream()) {
				Files.copy(in, saveTo, StandardCopyOption.REPLACE_EXISTING);
			}
			conn.disconnect();
			System.out.println("✅ Saved: " + saveTo.getFileName());
		} catch (Exception e) {
			System.err.println("❌ Error downloading " + fileUrl + ": " + e.getMessage());
		}
	}

	// Example usage
	public static void main(String[] args) {
		downloadBrainData(10, 2, "C:\\opt\\file");
	}
}