use std::{
    cell::{Ref, RefCell},
    fmt, io,
    time::Duration,
};

use console::style;
use indicatif::{ProgressBar, ProgressStyle};
use log::{debug, warn};

use crate::{
    cachefile::CacheFile,
    cli::Cli,
    file::{self, Chunk, FileTrait},
    sharry::{self, Client},
};

pub struct AppState {
    progress: RefCell<Option<ProgressBar>>,
    http: ureq::Agent,
    inner: CacheFile,
}

impl fmt::Debug for AppState {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AppState")
            .field("inner", &self.inner)
            .finish_non_exhaustive()
    }
}

fn new_http(timeout: Option<Duration>) -> ureq::Agent {
    ureq::Agent::config_builder()
        .timeout_global(timeout)
        .build()
        .into()
}

impl AppState {
    fn new(http: ureq::Agent, inner: CacheFile) -> Self {
        Self {
            progress: RefCell::new(None),
            http,
            inner,
        }
    }

    pub fn try_resume(args: &Cli) -> Option<Self> {
        let inner = CacheFile::try_resume(args)
            .inspect_err(|e| debug!("could not resume from hash {:?}: {e}", args.get_hash()))
            .ok()?;

        Some(Self::new(new_http(args.get_timeout()), inner))
    }

    pub fn from_args(args: &Cli) -> sharry::Result<Self> {
        let http = new_http(args.get_timeout());

        let share_id = http.share_create(&args.get_uri(), &args.alias, args.get_share_request())?;

        Ok(Self::new(http, CacheFile::from_args(args, share_id)))
    }

    fn get_or_create_progressbar(&self, uploading: &file::Uploading) -> Ref<'_, ProgressBar> {
        let mut slot = self.progress.borrow_mut();
        if slot.is_none() {
            let bar = ProgressBar::new(uploading.get_size())
                .with_style(
                    ProgressStyle::with_template(&format!(
                        concat!(
                            "{{bar:50.cyan/blue}} {{msg:.magenta}}: ",
                            "{{binary_bytes:.yellow}}{}{{binary_total_bytes:.yellow}} ",
                            "({{eta}})",
                        ),
                        style("/").magenta(),
                    ))
                    .expect("style template is not valid"),
                )
                .with_position(uploading.get_offset())
                .with_message(uploading.get_name().to_owned());

            bar.enable_steady_tick(Duration::from_millis(100));
            *slot = Some(bar);
        }
        drop(slot);

        Ref::map(self.progress.borrow(), |opt| {
            opt.as_ref().expect("somehow the slot holds None")
        })
    }

    fn drop_progressbar(&self, f: impl FnOnce(&ProgressBar)) {
        let mut slot = self.progress.borrow_mut();
        if let Some(bar) = slot.as_ref() {
            f(bar);
            *slot = None;
        }
    }

    fn next_chunk<'t>(&mut self, buffer: &'t mut [u8]) -> sharry::Result<Option<Chunk<'t>>> {
        let Some(mut uploading) = self.inner.pop_uploading(&self.http)? else {
            self.inner
                .share_notify(&self.http)
                .unwrap_or_else(|e| warn!("Failed to notify the share: {e}"));

            return Ok(None);
        };
        debug!("{uploading:?}");

        self.get_or_create_progressbar(&uploading);

        let chunk = {
            let result = uploading.read(buffer);
            self.inner.push_uploading(uploading);

            result?
        };
        debug!("{chunk:?}");

        Ok(Some(chunk))
    }

    fn is_done(&mut self) -> bool {
        if let Some(path) = self.inner.check_eof() {
            debug!("Finished {:?}!", path.display());
            self.drop_progressbar(ProgressBar::finish);
        } else if let Some(uploading) = self.inner.peek_uploading() {
            let bar = self.get_or_create_progressbar(uploading);
            bar.set_position(uploading.get_offset());
            // BUG in `indicatif` crate?
            // `set_position` does not force an immediate redraw, so we also call `inc_length` here
            bar.inc_length(0);

            return false;
        }

        self.inner.queue_empty()
    }

    pub fn upload_chunk(&mut self, buffer: &mut [u8]) -> sharry::Result<bool> {
        let Some(chunk) = self.next_chunk(buffer)? else {
            return Ok(true);
        };

        self.inner.file_patch(&self.http, &chunk)?;

        Ok(self.is_done())
    }

    pub fn rewind_chunk(mut self) -> Option<Self> {
        let uploading = if let Some(state) = self.inner.pop_file() {
            match state {
                FileState::U(s) => s,
                FileState::C(s) => {}
            }
        } else {
            warn!("rewind_chunk called on empty queue");
            return None;
        };

        let Some(FileState::U(uploading)) = self.inner.pop_file() else {
            warn!("rewind_chunk called in invalid state");
            return None;
        };

        self.inner.push_file(FileState::U(uploading.rewind()?));

        Some(self)
    }

    pub fn requeue_file(mut self) -> Option<Self> {
        let Some(uploading) = self.inner.pop_file(&self.http) else {
            warn!("requeue_file called on empty queue");
            return None;
        };

        let checked = uploading.abort();
        self.inner.requeue_file(checked);

        self.drop_progressbar(|pb| pb.abandon());

        Some(self)
    }

    pub fn rebuild_share(self, args: &Cli) -> sharry::Result<Self> {
        let share_id =
            self.http
                .share_create(&args.get_uri(), &args.alias, args.get_share_request())?;

        Ok(Self::new(self.http, CacheFile::from_args(args, share_id)))
    }

    pub fn file_names(&self) -> Vec<&str> {
        self.inner.file_names()
    }

    pub fn save(&self) -> io::Result<()> {
        self.inner.save()
    }

    pub fn clear(self) -> io::Result<()> {
        self.inner.clear()
    }
}