gulp-expl

import gulp from 'gulp';
import plumber from 'gulp-plumber';
import concat from 'gulp-concat';
import babel from 'gulp-babel';
import postcss from 'gulp-postcss';
import autoprefixer from 'autoprefixer';
import assets from 'postcss-assets';
import nested from 'postcss-nested';
import pre from 'precss';
import crip from 'postcss-crip';
import calc from 'postcss-calc';
import vizits from '../../app/vizit.js';
import jeditor from 'gulp-json-editor';
import glob from 'glob';
import errorHandler from '../utils/errorHandler';
import rename from "gulp-rename";
import fs from 'fs'
import runSequence from 'run-sequence'
import vm from 'vm'

function razvernutMasiv(arr) {
  return arr.reduce((acc, currElem) => {
    if (Array.isArray(currElem)) {
      return acc.concat(razvernutMasiv(currElem))
    } else {
      return acc.concat(currElem)
    }
  }, [])
}

gulp.task('vizit:delete', (cb) => {
  function deleteFolderRecursive(path) {
    if (fs.existsSync(path)) {
      fs.readdirSync(path).forEach(function (file, index) {
        var curPath = path + "/" + file;
        if (fs.lstatSync(curPath).isDirectory()) { // recurse
          deleteFolderRecursive(curPath);
        } else { // delete file
          fs.unlinkSync(curPath);
        }
      });
      fs.rmdirSync(path);
    }
  }
  deleteFolderRecursive('./vizits')
  cb();
});



gulp.task('vizit:build:core', function () {

  let pipeLine = gulp.src('dist/core/**/*')
  vizits
    .map(vizit => 'vizits/' + vizit.name + '/core/')
    .forEach(vizit => pipeLine = pipeLine.pipe(gulp.dest(vizit)))
  return pipeLine;
})


gulp.task('vizit:build:pdf', function () {

  let pipeLine = gulp.src('app/pdf/*')
  vizits
    .map(vizit => 'vizits/' + vizit.name + '/pdf')
    .forEach(vizit => pipeLine = pipeLine.pipe(gulp.dest(vizit)))

  return pipeLine;

})

gulp.task('vizit:build:pdf:new', function (cb) {
  const sandbox = {}
  vm.createContext(sandbox); // Contextify the sandbox.
  const code = fs.readFileSync('app/blocks/reference/reference-data.js', 'utf8')
  vm.runInContext(code, sandbox);



  function getUniqPdfs(vizits) {
    let presPdfs = [];

    // ADD INSTUCTION PDFS
    sandbox.instructions.forEach(instuction => {
      vizits.map(presentation => {
        presPdfs.push({
          dist: presentation.name,
          pdf: instuction
        })
      })
    })

    // ADD RESF PDFS
    new Set(razvernutMasiv(vizits.map(presentation => {
      const { referenceAll, REFERENCE_ALL } = sandbox
      return presentation.slides.concat(presentation.dops).map(slide => {
        if (referenceAll.hasOwnProperty(slide))
          return referenceAll[slide].map(reference => {
            if (REFERENCE_ALL.pdfs[reference.split('|')[0]]) {
              return {
                dist: presentation.name,
                pdf: REFERENCE_ALL.pdfs[reference.split('|')[0]]
              }
            }
          })
      })
    }))
      .filter(el => el)
      .map(el => JSON.stringify(el)))
      .forEach(el => presPdfs.push(JSON.parse(el)))


    return presPdfs.reduce((acc, el) => {
      if (!acc.hasOwnProperty(el.pdf)) {
        acc[el.pdf] = [el.dist]
        return acc
      }
      if (acc.hasOwnProperty(el.pdf)) {
        if (acc[el.pdf].indexOf(el.dist) === -1) {
          acc[el.pdf].push(el.dist)
        }
        return acc
      }
    }, {})
  }

  const uniqPdfs = getUniqPdfs(vizits)
  // console.log('vizit::pdfs', uniqPdfs)
  return runSequence(...Object.keys(uniqPdfs).map(pdf => {
    gulp.task(`vizit:build:pdf:new:${pdf}`, () => {

      const pipeLine = gulp.src(`app/pdf/${pdf}.**`)
      uniqPdfs[pdf].map(dist => {
        pipeLine.pipe(gulp.dest('vizits/' + dist + '/pdf'))
      })
      return pipeLine

    })
    return `vizit:build:pdf:new:${pdf}`
  }),cb)
})


gulp.task('vizit:build:global', function () {

  let pipeLine = gulp.src(['dist/global/**/*', '!dist/global/img/slides/**', '!dist/global/css/main.css', '!dist/global/js/slides.js'])
  vizits
    .map(vizit => 'vizits/' + vizit.name + '/global')
    .forEach(vizit => pipeLine = pipeLine.pipe(gulp.dest(vizit)))
  return pipeLine
})


gulp.task('vizit:build:presentation.html', function () {

  let pipeLine = gulp.src('dist/presentation.html')
  vizits
    .map(vizit => 'vizits/' + vizit.name)
    .forEach(vizit => pipeLine = pipeLine.pipe(gulp.dest(vizit)))
  return pipeLine;
})

gulp.task('vizit:build:json', function (cb) {

  function nextSlide(vizit, slide, index) {
    if (vizit["slideForceNext"] && vizit["slideForceNext"][slide]) {
      let slideName = vizit["slideForceNext"][slide]
      return vizit["slidesId"][slideName] || -1;
    } else {
      return vizit["slides"][index + 1] ? vizit["slidesId"][vizit["slides"][index + 1]] : -1;
    }
  }

  return runSequence( ...vizits.map((vizit) => {
    gulp.task(`vizit:build:json:${vizit.name}`, ()=> {
      return gulp.src('app/scenarioEx.json')
        .pipe(jeditor({
          "content": {
            "name": `${vizit.name}`,
            "version": Date.now()
          },
          "config": {
            "swipe": {
              "native": false,
              "left": "SWIPE_LEFT_NEW()",
              "right": "SWIPE_RIGHT_NEW()",
              "up": "SWIPE_UP()",
              "down": "SWIPE_DOWN()"
            }
          },
          "questions": [],
          scenario: [...(vizit["slides"].concat(vizit["dops"]).map((slide, index, arr) => {
            let newObj = {
              "folder": "slide_" + slide,
              // "next_slide": vizit["slides"][index+1] ? vizit["slidesId"][vizit["slides"][index+1]] : -1,
              "next_slide": nextSlide(vizit, slide, index),
              "name": '' + slide,
              "id": vizit["slidesId"][slide] || index + 1,
              "description": "",
              "prev_slide": -1,
              "isDop": vizit["dops"].indexOf(slide) !== -1 ? true : false,
              "product": vizit["slidesProduct"][slide]
            }
            if (index == 0) {
              newObj.is_first = true
            }
            return newObj;
          }))]
        }))
        .pipe(rename({
          basename: "scenario"
        }))
        .pipe(gulp.dest(`vizits/${vizit.name}/config/`))

    })
    return `vizit:build:json:${vizit.name}`
  }),cb)
})

gulp.task('vizit:build:css:global', function () {

  let blockPaths = glob.sync('*', {
    cwd: 'app/blocks/'
  }).map(block => 'blocks/' + block + '/img')

  let processors = [
    pre,
    crip,
    calc,
    nested,
    assets({
      loadPaths: blockPaths,
      basePath: 'app',
      baseUrl: '../img/'
    }),
    autoprefixer({
      browsers: ['last 40 version'],
    }),
  ];


  let pipeLine = gulp.src([
    'app/styles/**/*.css',
    'app/blocks/**/*.css',
  ])

  vizits
    .map(vizit => `vizits/${vizit.name}/global/css/`)
    .forEach(vizit => pipeLine = pipeLine
      .pipe(plumber({
        errorHandler: errorHandler,
      }))
      .pipe(concat('main.css'))
      .pipe(postcss(processors))
      .pipe(gulp.dest(vizit)))
  return pipeLine;

})

gulp.task('vizit:test:pre:build:slide:exists', function () {
  return vizits.map((vizit) => {
    return vizit["slides"].concat(vizit["dops"]).map((slide) => {
      if (fs.existsSync('dist/slide_' + slide)) {
        // Do something
        return gulp.src('dist/slide_' + slide + '/*.html')
          .pipe(gulp.dest('vizits/' + vizit.name + '/slide_' + slide))
      } else {
        throw `Нехватает слайда для визита ${slide} слайда нет для ${vizit.name}`
      }
    });
  })
})

gulp.task('vizit:build:copy:slide:image', (cb) =>
  runSequence(...razvernutMasiv(vizits.map((vizit) => {
    return vizit["slides"].concat(vizit["dops"]).map((slide) => {
      gulp.task(`vizit:build:copy:slide:image:${vizit.name}_${slide}`, () =>
        gulp.src('dist/global/img/slides/' + slide + '/**/*')
          .pipe(gulp.dest('vizits/' + vizit.name + '/global/img/slides/' + slide))
      )
      return `vizit:build:copy:slide:image:${vizit.name}_${slide}`;
    })
  })), cb)
)

gulp.task('vizit:build:copy:previews', function (cb) {
  runSequence(...razvernutMasiv(vizits.map((vizit) => {
    return vizit["slides"].concat(vizit["dops"]).map((slide) => {
      gulp.task(`vizit:build:copy:previews:${vizit.name}_${slide}`, () =>
        gulp.src(`dist/slide_${slide}/*.jpg`)
          .pipe(gulp.dest(`vizits/${vizit.name}/slide_${slide}`)))
      return `vizit:build:copy:previews:${vizit.name}_${slide}`
    })
  })),cb)
});


gulp.task('vizit:build:copy:first:previews', function (cb) {
  runSequence(...vizits.map((vizit) => {
    gulp.task(`vizit:build:copy:first:previews:${vizit.name}`, () =>
      gulp.src(`dist/slide_${vizit["slides"][0]}/*.jpg`)
        .pipe(gulp.dest(`vizits/${vizit.name}`))
    )
    return `vizit:build:copy:first:previews:${vizit.name}`
  }),cb)
});

gulp.task('vizit:build:slides:js', function (cb) {
  runSequence(vizits.map((vizit) => {
    gulp.task(`vizit:build:slides:js:${vizit.name}`, () =>
      gulp.src(vizit["slides"].concat(vizit["dops"]).map((slide) => `app/slides/${slide}/${slide}.js`))
        .pipe(babel())
        .pipe(concat('slides.js'))
        .pipe(gulp.dest(`vizits/${vizit.name}/global/js/`))
    )
    return `vizit:build:slides:js:${vizit.name}`
  }),cb)
})

gulp.task('vizit:build:css:slides', function (cb) {
  runSequence(...vizits.map((vizit) => {
    gulp.task(`vizit:build:css:slides:${vizit.name}`, () =>
      gulp.src(vizit["slides"].concat(vizit["dops"]).map(slide => `dist/tmp/css/${slide}.css`))
        .pipe(plumber({
          errorHandler: errorHandler,
        }))
        .pipe(concat('slides.css'))
        .pipe(gulp.dest(`vizits/${vizit.name}/global/css/`))
    )
    return `vizit:build:css:slides:${vizit.name}`
  }),cb)
})



gulp.task('vizit', (cb) => {
  runSequence(
    'vizit:delete',
    'vizit:build:core',
    'vizit:build:copy:previews',
    'vizit:build:presentation.html',
    'vizit:build:css:global',
    'vizit:build:slides:js',
    'vizit:build:copy:slide:image',
    'vizit:build:copy:first:previews',
    'vizit:test:pre:build:slide:exists',
    'vizit:build:css:slides',
    'vizit:build:global',
    'vizit:build:json',
    'vizit:build:pdf:new',
    cb
  )
})
// 'vizit:delete', 'vizit:build'