use crate::config::Config;
use collective::rundir::{self, RunDir};
use s3::packager::S3BundlePackager;
use serde::Serialize;
use snafu::{ResultExt, Snafu};
use std::{path::PathBuf, sync::Arc};
use tokio::{
  sync::RwLock,
  time::{interval, Duration},
};

use self::{local_dir::poller::LocalBundlePoller, s3::poller::S3BundlePoller};

pub mod local_dir;
pub mod packager;
pub mod poller;
pub mod s3;

#[derive(Snafu, Debug)]
pub enum Error {
  InitRunDir { source: rundir::RunDirError },
  DeinitRunDir { source: rundir::RunDirError },
  LockRead,
  LockWrite,
  AttachSignalHook { source: std::io::Error },
  MissingETag,
  PollError { source: poller::Error },
  SubDirError { source: rundir::RunDirError },
}

type Result<T, E = Error> = std::result::Result<T, E>;

#[derive(Copy, Clone, Debug, Serialize, PartialEq)]
pub enum UnbundlerStatus {
  /// Poller is instantiated but not initialized.
  Idle = 0,
  /// Poller is initialized.
  Initialized = 1,
  /// Poller is performing it's initial poll.
  InitialPolling = 2,
  /// Poller has set up a bundle and is ready to be served.
  Ready = 3,
  /// Poller is checking for bundle updates.
  Polling = 4,
}

#[derive(Clone)]
pub struct Bundle {
  etag: Option<String>,
}

pub struct Bundler {
  packager: Box<dyn packager::BundlePackager + Sync + Send>,
}

impl Bundler {
  pub fn new(config: Arc<Config>) -> Bundler {
    let packager: Box<dyn packager::BundlePackager + Sync + Send> = match &config.bundle {
      crate::config::BundleConfig::S3Bundle {
        access_key,
        secret_key,
        endpoint,
        bucket,
        region,
        object_name,
      } => Box::new(S3BundlePackager::new(
        access_key.clone(),
        secret_key.clone(),
        endpoint.clone(),
        bucket.clone(),
        region.clone(),
        object_name.clone(),
      )),
      crate::config::BundleConfig::LocalBundle { dir: _ } => {
        panic!("Local bundler is not currently implemented.")
      }
    };

    Bundler { packager }
  }

  pub async fn package(&self, path: PathBuf) -> Result<(), packager::Error> {
    log::info!("Packaging bundle at {}", path.display());

    self.packager.generate(path).await
  }
}

struct UnbundlerState {
  rundir: RunDir,
  status: UnbundlerStatus,
  active_bundle: Option<Bundle>,
  staging_bundle: Option<Bundle>,
  temp_dir: Option<PathBuf>,
}

pub struct Unbundler {
  config: Arc<Config>,
  serve_dir: Arc<RwLock<Option<PathBuf>>>,
  state: RwLock<UnbundlerState>,
  poller: Box<dyn poller::BundlePoller + Sync + Send>,
}

impl Unbundler {
  pub fn new(config: Arc<Config>, serve_dir: Arc<RwLock<Option<PathBuf>>>) -> Unbundler {
    let mut rundir = RunDir::new(config.server.run_dir.clone());

    if let Some(allow_cleaning) = config.server.auto_cleanup {
      rundir = rundir.allow_cleaning(allow_cleaning);
    }

    let poller: Box<dyn poller::BundlePoller + Sync + Send> = match &config.bundle {
      crate::config::BundleConfig::S3Bundle {
        access_key,
        secret_key,
        endpoint,
        bucket,
        region,
        object_name,
      } => Box::new(S3BundlePoller::new(
        access_key.clone(),
        secret_key.clone(),
        endpoint.clone(),
        bucket.clone(),
        region.clone(),
        object_name.clone(),
      )),
      crate::config::BundleConfig::LocalBundle { dir } => {
        Box::new(LocalBundlePoller::new(dir.clone()))
      }
    };

    Unbundler {
      config,
      state: RwLock::new(UnbundlerState {
        rundir,
        status: UnbundlerStatus::Idle,
        active_bundle: None,
        staging_bundle: None,
        temp_dir: None,
      }),
      poller,
      serve_dir,
    }
  }

  pub async fn get_status(&self) -> Result<UnbundlerStatus> {
    let state = self.state.read().await;

    Ok(state.status)
  }

  pub async fn get_serve_dir(&self) -> Result<Option<PathBuf>> {
    let serve_dir = self.serve_dir.read().await;

    Ok(serve_dir.clone())
  }

  pub async fn enter(&self) -> Result<()> {
    self.init().await?;

    let mut interval = interval(Duration::from_secs(self.config.unbundler.poll_seconds));
    let ctrl_c_fut = tokio::signal::ctrl_c();

    tokio::pin!(ctrl_c_fut);

    loop {
      let me = self;

      tokio::select! {
          _ = &mut ctrl_c_fut => {
            break;
          }
          _ = interval.tick() => {
            match me.poll().await {
                Ok(_) => {}
                Err(err) => log::error!("Unbundler: Got an error while invoking poller: {:?}", err),
            };
          }
      }
    }

    self.deinit().await
  }

  async fn init(&self) -> Result<()> {
    log::info!("Unbundler: Initializing...");

    let mut state = self.state.write().await;

    state.rundir.initialize().context(InitRunDir)?;
    state.temp_dir = Some(state.rundir.create_subdir("temp").context(InitRunDir)?);

    state.status = UnbundlerStatus::Initialized;

    Ok(())
  }

  async fn poll(&self) -> Result<()> {
    log::info!("Unbundler: Checking for updates...");

    // Update state on a spearate scope to avoid holding a write lock while
    // the poller runs.
    //
    // Lock will be released when `initial_state` goes out of scope.
    let active_bundle = {
      let mut initial_state = self.state.write().await;

      let active_bundle = initial_state.active_bundle.clone();
      if active_bundle.is_none() {
        initial_state.status = UnbundlerStatus::InitialPolling;
      } else {
        initial_state.status = UnbundlerStatus::Polling;
      }

      active_bundle
    };

    // Invoke the poller.
    let result = match self.poller.poll(&active_bundle).await {
      Err(err) => {
        let mut state = self.state.write().await;

        // Rollback status if the poll fails.
        if active_bundle.is_none() {
          state.status = UnbundlerStatus::Initialized;
        } else {
          state.status = UnbundlerStatus::Ready;
        }

        Err(err)
      }
      res => res,
    }
    .context(PollError)?;

    match result {
      poller::PollResult::Skip => {
        let mut state = self.state.write().await;

        state.status = UnbundlerStatus::Ready;

        log::info!("Unbundler: No updates from poller.");

        Ok(())
      }
      poller::PollResult::StaticUpdateReady { etag, path } => {
        let mut state = self.state.write().await;

        // Replacing active bundle.
        state.active_bundle = Some(Bundle { etag });
        state.staging_bundle = None;
        state.status = UnbundlerStatus::Ready;

        let mut serve_dir = self.serve_dir.write().await;

        serve_dir.replace(path);

        Ok(())
      }
      poller::PollResult::UpdateReady { etag } => {
        let mut state = self.state.write().await;

        if state.rundir.subdir_exists(&etag).context(SubDirError)? {
          log::warn!("Unbundler: Skipping update. Subdir already exists.");

          return Ok(());
        }

        state.staging_bundle = Some(Bundle {
          etag: Some(etag.clone()),
        });

        let newdir = state.rundir.create_subdir(&etag).context(SubDirError)?;

        let result = self.poller.retrieve(&etag, newdir.clone()).await;

        if result.is_err() {
          log::warn!("Unbundler: Poller failed to retrieve new bundle. Rolling back.");

          state.staging_bundle = None;
          state.status = UnbundlerStatus::Ready;

          state.rundir.remove_subdir_all(&etag).context(SubDirError)?;

          return Ok(());
        }

        // Replacing active bundle.
        state.active_bundle = state.staging_bundle.clone();
        state.staging_bundle = None;
        state.status = UnbundlerStatus::Ready;

        let mut serve_dir = self.serve_dir.write().await;

        serve_dir.replace(newdir);

        Ok(())
      }
    }
  }

  async fn deinit(&self) -> Result<()> {
    let mut state = self.state.write().await;

    state.status = UnbundlerStatus::Idle;
    state.rundir.cleanup().context(DeinitRunDir)?;

    Ok(())
  }
}