import { PrismaClient } from '@prisma/client';
import { defaultDatasetsFolder, defaultDataRoot } from '@/paths';
import { defaultTrainFolder } from '@/paths';
import NodeCache from 'node-cache';
import { usingBrowserDb } from '@/utils/env';

const myCache = new NodeCache();

const isBrowserMode = usingBrowserDb || (process.env.DB_MODE || '').toLowerCase() === 'browser';

const prisma = !isBrowserMode ? new PrismaClient() : null;

const safeSettingLookup = async (key: string) => {
  if (!prisma) {
    return null;
  }
  try {
    return await prisma.settings.findFirst({ where: { key } });
  } catch (error) {
    console.error(`Prisma settings lookup failed for key ${key}:`, error);
    return null;
  }
};

const envOrDefault = (envValue: string | undefined, fallback: string) => {
  if (envValue && envValue.trim() !== '') {
    return envValue.trim();
  }
  return fallback;
};

export const flushCache = () => {
  myCache.flushAll();
};

export const getDatasetsRoot = async () => {
  const key = 'DATASETS_FOLDER';
  let datasetsPath = myCache.get(key) as string;
  if (datasetsPath) {
    return datasetsPath;
  }
  if (isBrowserMode) {
    datasetsPath = envOrDefault(process.env.DATASETS_FOLDER, defaultDatasetsFolder);
  } else {
    const row = await safeSettingLookup('DATASETS_FOLDER');
    datasetsPath = envOrDefault(process.env.DATASETS_FOLDER, defaultDatasetsFolder);
    if (row?.value && row.value !== '') {
      datasetsPath = row.value;
    }
  }
  myCache.set(key, datasetsPath);
  return datasetsPath as string;
};

export const getTrainingFolder = async () => {
  const key = 'TRAINING_FOLDER';
  let trainingRoot = myCache.get(key) as string;
  if (trainingRoot) {
    return trainingRoot;
  }
  if (isBrowserMode) {
    trainingRoot = envOrDefault(process.env.TRAINING_FOLDER, defaultTrainFolder);
  } else {
    const row = await safeSettingLookup(key);
    trainingRoot = envOrDefault(process.env.TRAINING_FOLDER, defaultTrainFolder);
    if (row?.value && row.value !== '') {
      trainingRoot = row.value;
    }
  }
  myCache.set(key, trainingRoot);
  return trainingRoot as string;
};

export const getHFToken = async () => {
  const key = 'HF_TOKEN';
  let token = myCache.get(key) as string;
  if (token) {
    return token;
  }
  if (isBrowserMode) {
    token = envOrDefault(process.env.HF_TOKEN, '');
  } else {
    const row = await safeSettingLookup(key);
    token = envOrDefault(process.env.HF_TOKEN, '');
    if (row?.value && row.value !== '') {
      token = row.value;
    }
  }
  myCache.set(key, token);
  return token;
};

export const getDataRoot = async () => {
  const key = 'DATA_ROOT';
  let dataRoot = myCache.get(key) as string;
  if (dataRoot) {
    return dataRoot;
  }
  if (isBrowserMode) {
    dataRoot = envOrDefault(process.env.DATA_ROOT, defaultDataRoot);
  } else {
    const row = await safeSettingLookup(key);
    dataRoot = envOrDefault(process.env.DATA_ROOT, defaultDataRoot);
    if (row?.value && row.value !== '') {
      dataRoot = row.value;
    }
  }
  myCache.set(key, dataRoot);
  return dataRoot;
};