// Import required packages
import gulp from 'gulp';
import concat from 'gulp-concat';
import terser from 'gulp-terser';
import cleanCSS from 'gulp-clean-css';
import rename from 'gulp-rename';
import fs from 'fs';
import path from 'path';
import mergeStream from 'merge-stream';

// Vendor names for backend and frontend
const backend_vendors = [
  "datatables", "webfont", "select2", "slick", "markerclustererplus",
  "accordion", "flippercode", "fc-customizer", "bootstrap-modal","backend"
];

const frontend_vendors = [
  "datatables", "jscrollpane", "marker-spidifier", "print",
  "markerclustererplus", "accordion", "webfont", "frontend"
];

const leaflet_plugins = [
  "leaflet/plugins/provider","leaflet/plugins/autocomplete","leaflet/plugins/fullscreen","leaflet/plugins/locate","leaflet/plugins/route","leaflet/plugins/googlecompat"
];

// Paths
const vendorPath = 'assets/js/vendor';
const cssDest = 'assets/css';
const jsDest = 'assets/js';

// Helper function: Minify and concatenate vendor JS files
function processVendorScripts(vendors, outputName) {
  const paths = vendors.map(v => `${vendorPath}/${v}/*.js`);
  return gulp
    .src(paths)
    .pipe(concat(`${outputName}.js`))     
    .pipe(gulp.dest(jsDest))
    .pipe(terser())
    .pipe(rename(`${outputName}.min.js`))
    .pipe(gulp.dest(jsDest));
}

// Helper function: Minify and concatenate vendor CSS files
function processVendorCSS(vendors, outputName) {
  const paths = vendors.map(v => `${vendorPath}/${v}/*.css`);
  return gulp
    .src(paths)
    .pipe(concat(`${outputName}.css`))
    .pipe(gulp.dest(cssDest))
    .pipe(rename(`${outputName}.min.css`))
    .pipe(cleanCSS())
    .pipe(gulp.dest(cssDest));
}

function minifyCSS(src, outputName, dest) {
  return function () {
    return gulp
      .src(src)
      .pipe(cleanCSS())
      .pipe(rename(outputName))
      .pipe(gulp.dest(dest));
  };
}

// Backend JS task
gulp.task('backend-scripts', () => {
  return processVendorScripts(backend_vendors, 'wpgmp_backend');
});

// Frontend JS task
gulp.task('frontend-scripts', () => {
  return processVendorScripts(frontend_vendors, 'wpgmp_frontend');
});

// Leaflet Plugins JS task
gulp.task('leaflet-plugins-scripts', () => {
  return processVendorScripts(leaflet_plugins, 'wpgmp_leaflet_plugins');
});

// Leaflet Plugins JS task
gulp.task('leaflet-plugins-css', () => {
  return processVendorCSS(leaflet_plugins, 'wpgmp_leaflet_plugins');
});

// File paths
const mapsJSFiles = [
  `${vendorPath}/maps/baseMaps.js`,
  `${vendorPath}/maps/googleMaps.js`,
  `${vendorPath}/maps/leafletMaps.js`,
  `${vendorPath}/maps/mapFactory.js`,
  `${vendorPath}/maps/generateMaps.js` // your initialization script
];

// Task to combine and minify map provider scripts
gulp.task('minify-mapsjs', function () {
  return gulp.src(mapsJSFiles)
    .pipe(concat('wpgmp_maps.js'))               // Combine all into maps.js
    .pipe(gulp.dest(jsDest))              // Output unminified version
    .pipe(rename('wpgmp_maps.min.js')) // Rename for minified version
    .pipe(terser())
    .pipe(gulp.dest(jsDest));             // Save maps.min.js
});

gulp.task('minify-leafletjs', function () {
  return gulp.src(`${vendorPath}/leaflet/leaflet.js`)
    .pipe(rename('wpgmp_leaflet.js'))               // Combine all into maps.js
    .pipe(gulp.dest(jsDest))              // Output unminified version
    .pipe(rename('wpgmp_leaflet.min.js')) // Rename for minified version
    .pipe(terser())
    .pipe(gulp.dest(jsDest));             // Save maps.min.js
});

// Minify Individual CSS file

const cssFiles = [
  { input: `${cssDest}/wpgmp_frontend.css`, output: 'wpgmp_frontend.min.css' },
  { input: `${cssDest}/wpgmp_backend.css`, output: 'wpgmp_backend.min.css' },
  { input: `${cssDest}/wpgmp_templates.css`, output: 'wpgmp_templates.min.css' },
  { input: `${cssDest}/wpgmp_infowindows.css`, output: 'wpgmp_infowindows.min.css' },
  { input: `${cssDest}/wpgmp_webfonts.css`, output: 'wpgmp_webfonts.min.css' },
  { input: `${cssDest}/leaflet.css`, output: 'leaflet.min.css' },
];

gulp.task('minify-all-css', () => {
  const tasks = cssFiles.map(file =>
    gulp
      .src(file.input)
      .pipe(cleanCSS())
      .pipe(rename(file.output))
      .pipe(gulp.dest(cssDest))
  );

  return mergeStream(...tasks);
});

// Backend CSS task: Combine vendor and dynamic template styles
gulp.task('backend-css', (cb) => {
  const vendorCSS = backend_vendors.map(v => `${vendorPath}/${v}/*.css`);
  const templateCSS = [];

  const basePath = path.resolve('templates');

  fs.readdirSync(basePath).forEach((category) => {
    const categoryPath = path.join(basePath, category);
    if (!fs.statSync(categoryPath).isDirectory()) return;

    fs.readdirSync(categoryPath).forEach((folder) => {
      const cssFile = path.join(categoryPath, folder, `${folder}.css`);
      if (fs.existsSync(cssFile)) templateCSS.push(cssFile);
    });
  });

  const allCSS = vendorCSS.concat(templateCSS);

  return gulp
    .src(allCSS, { allowEmpty: true })
    .pipe(concat('wpgmp_vendors.css'))
    .pipe(gulp.dest(cssDest))
    .pipe(rename('wpgmp_vendors.min.css'))
    .pipe(cleanCSS())
    .pipe(gulp.dest(cssDest));
});


const backendCombinedJS = [
  `${jsDest}/wpgmp_leaflet.js`, 
  `${jsDest}/wpgmp_leaflet_plugins.js`, 
  `${jsDest}/wpgmp_maps.js`, 
];

// Task to combine and minify map provider scripts
gulp.task('combine-maps-js', function () {
  return gulp.src(backendCombinedJS)
    .pipe(concat('maps.js'))               // Combine all into maps.js
    .pipe(gulp.dest(jsDest))              // Output unminified version
    .pipe(rename('maps.min.js')) // Rename for minified version
    .pipe(terser())
    .pipe(gulp.dest(jsDest));             // Save maps.min.js
});

const backendCombinedCSS = [
  `${cssDest}/font_family.css`, 
  `${cssDest}/leaflet.css`, 
  `${cssDest}/wpgmp_vendors.css`, 
  `${cssDest}/wpgmp_templates.css`,
  `${cssDest}/wpgmp_leaflet_plugins.css`,
  `${cssDest}/wpgmp_infowindows.css`, 
  `${cssDest}/wpgmp_webfonts.css`,
  `${cssDest}/wpgmp_backend.css`, 

];

// Task to combine and minify map provider scripts
gulp.task('combine-backend-css', function () {
  return gulp.src(backendCombinedCSS)
    .pipe(concat('wpgmp_all_backend.css'))               // Combine all into maps.js
    .pipe(gulp.dest(cssDest))              // Output unminified version
    .pipe(rename('wpgmp_all_backend.min.css')) // Rename for minified version
    .pipe(cleanCSS())
    .pipe(gulp.dest(cssDest));             // Save maps.min.js
});

const frontendCombinedCSS = [
  `${cssDest}/wpgmp_frontend.css`, 
  `${cssDest}/wpgmp_leaflet_plugins.css`,
  `${cssDest}/wpgmp_infowindows.css`, 
  `${cssDest}/wpgmp_webfonts.css`,
  `${cssDest}/leaflet.css`
];

// Task to combine and minify map provider scripts
gulp.task('combine-frontend-css', function () {
  return gulp.src(frontendCombinedCSS)
    .pipe(concat('wpgmp_all_frontend.css'))               // Combine all into maps.js
    .pipe(gulp.dest(cssDest))              // Output unminified version
    .pipe(rename('wpgmp_all_frontend.min.css')) // Rename for minified version
    .pipe(cleanCSS())
    .pipe(gulp.dest(cssDest));             // Save maps.min.js
});

// Default task: Run all in sequence
gulp.task('default', gulp.series(
  'backend-scripts',
  'frontend-scripts',
  'minify-leafletjs',
  'leaflet-plugins-scripts',
  'leaflet-plugins-css',
  'minify-mapsjs',
  'backend-css',
  'minify-all-css',
  'combine-maps-js',
  'combine-backend-css',
  'combine-frontend-css'
));