use crate::Result;

use super::activity::Activity;
use super::activity::ActivityBuild;
use super::activity::ActivityBuildWaiting;
use super::activity::ActivityBuilds;
use super::activity::ActivityCopyPath;
use super::activity::ActivityCopyPaths;
use super::activity::ActivityFetchTree;
use super::activity::ActivityFileTransfer;
use super::activity::ActivityOptimizeStore;
use super::activity::ActivityPostBuildHook;
use super::activity::ActivityQueryPathInfo;
use super::activity::ActivityRealize;
use super::activity::ActivityState;
use super::activity::ActivitySubstitute;
use super::activity::ActivityUnknown;
use super::activity::ActivityVerifyPaths;
use super::activity_tree::ActivityTree;
use super::nix_output_stream::ActivityResultMessage;
use super::nix_output_stream::ActivityStartMessage;
use super::nix_output_stream::NixAction;
use super::nix_output_stream::NixMessage;

pub(crate) struct ActivityTreeStream {
    activity_tree: ActivityTree,
}

impl ActivityTreeStream {
    pub(crate) fn new() -> ActivityTreeStream {
        ActivityTreeStream {
            activity_tree: ActivityTree::new(),
        }
    }

    pub(crate) fn get_tree(&self) -> &ActivityTree {
        &self.activity_tree
    }

    pub(crate) fn get_tree_mut(&mut self) -> &mut ActivityTree {
        &mut self.activity_tree
    }

    pub(crate) fn handle_message(&mut self, message: &NixMessage) -> Result<()> {
        let message = match message {
            NixMessage::ParseFailure(_) | NixMessage::Generic(_, _) => {
                return Ok(());
            }
            NixMessage::Action(nix_action) => nix_action,
        };

        match message {
            NixAction::Msg(_msg_message) => {
                // if msg_message.msg.contains("nix log") {
                //     eprintln!("{}", msg_message.msg);
                // }
                // if msg_message.level == 0 {
                //     eprintln!("{}", msg_message.msg);
                // }
            }
            NixAction::Start(activity_start_message) => {
                match activity_start_message {
                    ActivityStartMessage::Unknown(activity_start_unknown) => {
                        self.activity_tree.add_activity(
                            activity_start_unknown.id,
                            activity_start_unknown.parent,
                            Activity::Unknown(ActivityUnknown {
                                state: ActivityState::default(),
                                text: activity_start_unknown.text.clone(),
                            }),
                        )?;
                    }
                    ActivityStartMessage::CopyPath(activity_start_copy_path) => {
                        self.activity_tree.add_activity(
                            activity_start_copy_path.id,
                            activity_start_copy_path.parent,
                            Activity::CopyPath(ActivityCopyPath {
                                state: ActivityState::default(),
                                missing_path: activity_start_copy_path.missing_path.clone(),
                                source: activity_start_copy_path.source.clone(),
                                destination: activity_start_copy_path.destination.clone(),
                                done: 0,
                                expected: 0,
                            }),
                        )?;
                    }
                    ActivityStartMessage::FileTransfer(activity_start_file_transfer) => {
                        self.activity_tree.add_activity(
                            activity_start_file_transfer.id,
                            activity_start_file_transfer.parent,
                            Activity::FileTransfer(ActivityFileTransfer {
                                state: ActivityState::default(),
                                url: activity_start_file_transfer.url.clone(),
                                done: 0,
                                expected: 0,
                            }),
                        )?;
                    }
                    ActivityStartMessage::Realize(activity_start_realize) => {
                        self.activity_tree.add_activity(
                            activity_start_realize.id,
                            activity_start_realize.parent,
                            Activity::Realize(ActivityRealize {
                                state: ActivityState::default(),
                            }),
                        )?;
                    }
                    ActivityStartMessage::CopyPaths(activity_start_copy_paths) => {
                        self.activity_tree.add_activity(
                            activity_start_copy_paths.id,
                            activity_start_copy_paths.parent,
                            Activity::CopyPaths(ActivityCopyPaths {
                                state: ActivityState::default(),
                                text: activity_start_copy_paths.text.clone(),
                                done: 0,
                                expected: 0,
                                running: 0,
                                failed: 0,
                            }),
                        )?;
                    }
                    ActivityStartMessage::Builds(activity_start_builds) => {
                        self.activity_tree.add_activity(
                            activity_start_builds.id,
                            activity_start_builds.parent,
                            Activity::Builds(ActivityBuilds {
                                state: ActivityState::default(),
                                done: 0,
                                expected: 0,
                                running: 0,
                                failed: 0,
                            }),
                        )?;
                    }
                    ActivityStartMessage::Build(activity_start_build) => {
                        self.activity_tree.add_activity(
                            activity_start_build.id,
                            activity_start_build.parent,
                            Activity::Build(ActivityBuild {
                                state: ActivityState::default(),
                                drv_path: activity_start_build.drv_path.clone(),
                                machine_name: if activity_start_build.machine_name.len() > 0 {
                                    Some(activity_start_build.machine_name.clone())
                                } else {
                                    None
                                },
                                phase: None,
                            }),
                        )?;
                    }
                    ActivityStartMessage::OptimizeStore(activity_start_optimize_store) => {
                        self.activity_tree.add_activity(
                            activity_start_optimize_store.id,
                            activity_start_optimize_store.parent,
                            Activity::OptimizeStore(ActivityOptimizeStore {
                                state: ActivityState::default(),
                            }),
                        )?;
                    }
                    ActivityStartMessage::VerifyPaths(activity_start_verify_paths) => {
                        self.activity_tree.add_activity(
                            activity_start_verify_paths.id,
                            activity_start_verify_paths.parent,
                            Activity::VerifyPaths(ActivityVerifyPaths {
                                state: ActivityState::default(),
                            }),
                        )?;
                    }
                    ActivityStartMessage::Substitute(activity_start_substitute) => {
                        self.activity_tree.add_activity(
                            activity_start_substitute.id,
                            activity_start_substitute.parent,
                            Activity::Substitute(ActivitySubstitute {
                                state: ActivityState::default(),
                            }),
                        )?;
                    }
                    ActivityStartMessage::QueryPathInfo(activity_start_query_path_info) => {
                        self.activity_tree.add_activity(
                            activity_start_query_path_info.id,
                            activity_start_query_path_info.parent,
                            Activity::QueryPathInfo(ActivityQueryPathInfo {
                                state: ActivityState::default(),
                            }),
                        )?;
                    }
                    ActivityStartMessage::PostBuildHook(activity_start_post_build_hook) => {
                        self.activity_tree.add_activity(
                            activity_start_post_build_hook.id,
                            activity_start_post_build_hook.parent,
                            Activity::PostBuildHook(ActivityPostBuildHook {
                                state: ActivityState::default(),
                            }),
                        )?;
                    }
                    ActivityStartMessage::BuildWaiting(activity_start_build_waiting) => {
                        self.activity_tree.add_activity(
                            activity_start_build_waiting.id,
                            0,
                            Activity::BuildWaiting(ActivityBuildWaiting {
                                state: ActivityState::default(),
                                text: activity_start_build_waiting.text.clone(),
                                drv_path: activity_start_build_waiting.drv_path.clone(),
                                path_resolved: activity_start_build_waiting.path_resolved.clone(),
                            }),
                        )?;
                    }
                    ActivityStartMessage::FetchTree(activity_start_fetch_tree) => {
                        self.activity_tree.add_activity(
                            activity_start_fetch_tree.id,
                            activity_start_fetch_tree.parent,
                            Activity::FetchTree(ActivityFetchTree {
                                state: ActivityState::default(),
                            }),
                        )?;
                    }
                };
            }
            NixAction::Stop(stop_message) => {
                let activity = self
                    .activity_tree
                    .get_activity_id(stop_message.id)
                    .map(|activity_id| self.activity_tree.get_mut(&activity_id))?;
                activity.get_mut_activity().stop();
                // println!("{}", serde_json::to_string(&message)?);
            }
            NixAction::Result(activity_result_message) => {
                match activity_result_message {
                    ActivityResultMessage::FileLinked(_activity_result_file_linked) => {}
                    ActivityResultMessage::BuildLogLine(_activity_result_build_log_line) => {
                        // These are the output from the actual build (as opposed to the output from nix).
                    }
                    ActivityResultMessage::UntrustedPath(_activity_result_untrusted_path) => {}
                    ActivityResultMessage::CorruptedPath(_activity_result_corrupted_path) => {}
                    ActivityResultMessage::SetPhase(activity_result_set_phase) => {
                        let activity_id = self
                            .activity_tree
                            .get_activity_id(activity_result_set_phase.id)?;
                        let activity = self.activity_tree.get_mut(&activity_id);
                        activity
                            .get_mut_activity()
                            .set_phase(Some(activity_result_set_phase.phase.clone()));
                    }
                    ActivityResultMessage::Progress(activity_result_progress) => {
                        let activity_id = self
                            .activity_tree
                            .get_activity_id(activity_result_progress.id)?;
                        let activity = self.activity_tree.get_mut(&activity_id);
                        activity.get_mut_activity().set_progress(
                            activity_result_progress.done,
                            activity_result_progress.expected,
                            activity_result_progress.running,
                            activity_result_progress.failed,
                        );
                    }
                    ActivityResultMessage::SetExpected(activity_result_set_expected) => {
                        let activity_id = self
                            .activity_tree
                            .get_activity_id(activity_result_set_expected.id)?;
                        let activity = self.activity_tree.get_mut(&activity_id);
                        activity
                            .get_mut_activity()
                            .set_expected(activity_result_set_expected.expected);
                    }
                    ActivityResultMessage::PostBuildLogLine(
                        _activity_result_post_build_log_line,
                    ) => {}
                    ActivityResultMessage::FetchStatus(_activity_result_fetch_status) => {}
                };
            }
        };
        Ok(())
    }
}