use super::{Object,ObjectExt};

#[derive(Debug)]
pub struct ClapInterface<O: ObjectExt> {
    verb: InterfaceVerb<O>,
    _ghost: std::marker::PhantomData<O>,
}

impl<O: ObjectExt> ClapInterface<O> {
    pub fn perform(
        &self,
        query_ctx: impl microrm::prelude::Queryable<EntityOutput = O>,
        insert_ctx: &impl microrm::prelude::Insertable<O>,
    ) -> Result<(), UIDCError> {
        match &self.verb {
            InterfaceVerb::Attach { relation, remote_keys } => {
                todo!()
            }
            InterfaceVerb::Create(params) => {
                O::create(insert_ctx, &params)?;
            }
            InterfaceVerb::Delete(keys) => {
                O::delete(query_ctx, O::build_keys(keys))?;
            }
            InterfaceVerb::Detach => {
                todo!()
            }
            InterfaceVerb::ListAll => {
                O::list_all(query_ctx)?;
            }
            InterfaceVerb::Inspect(keys) => {
                O::inspect(query_ctx, O::build_keys(keys))?;
            }
        }
        Ok(())
    }

    /// iterate across the list of key parts (O::Uniques) and add args for each
    fn add_keys(mut cmd: clap::Command) -> clap::Command {
        struct UVisitor<'a>(&'a mut clap::Command);
        impl<'a> EntityPartVisitor for UVisitor<'a> {
            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
                let arg = clap::Arg::new(EP::part_name())
                    .required(true)
                    .help(EP::desc());
                *self.0 = self.0.clone().arg(arg);
            }
        }

        <O::Uniques as EntityPartList>::accept_part_visitor(&mut UVisitor(&mut cmd));

        cmd
    }

    fn make_relation_subcommands() -> impl Iterator<Item = clap::Command> {
        let mut out = vec![];

        struct PartVisitor<'l>(&'l mut Vec<clap::Command>);
        impl<'l> EntityPartVisitor for PartVisitor<'l> {
            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
                struct Discriminator<'l>(&'l mut Vec<clap::Command>, &'static str);

                impl<'l> DatumDiscriminator for Discriminator<'l> {
                    fn visit_entity_id<E: Entity>(&mut self) {}
                    fn visit_serialized<T: serde::Serialize + serde::de::DeserializeOwned>(
                        &mut self,
                    ) {
                    }
                    fn visit_bare_field<T: Datum>(&mut self) {}
                    fn visit_assoc_map<E: Entity>(&mut self) {
                        self.0.push(clap::Command::new(self.1));
                    }
                    fn visit_assoc_domain<R: microrm::schema::Relation>(&mut self) {
                        self.0.push(clap::Command::new(self.1));
                    }
                    fn visit_assoc_range<R: microrm::schema::Relation>(&mut self) {
                        self.0.push(clap::Command::new(self.1));
                    }
                }

                <EP::Datum as Datum>::accept_discriminator(&mut Discriminator(
                    self.0,
                    EP::part_name(),
                ));
            }
        }

        O::accept_part_visitor(&mut PartVisitor(&mut out));

        out.into_iter()
    }
}

impl<O: ObjectExt> FromArgMatches for ClapInterface<O> {
    fn from_arg_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
        let verb = InterfaceVerb::from_matches(matches);

        Ok(Self {
            verb: verb?,
            _ghost: Default::default(),
        })
    }

    fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> {
        todo!()
    }
}

impl<O: ObjectExt> Subcommand for ClapInterface<O> {
    fn has_subcommand(name: &str) -> bool {
        todo!()
    }

    fn augment_subcommands(cmd: clap::Command) -> clap::Command {
        cmd.subcommand(
            Self::add_keys(clap::Command::new("attach"))
                .subcommands(Self::make_relation_subcommands())
                .subcommand_required(true),
        )
        .subcommand(<O::CreateParameters as clap::CommandFactory>::command().name("create"))
        .subcommand(Self::add_keys(clap::Command::new("delete")))
        .subcommand(Self::add_keys(clap::Command::new("inspect")))
        .subcommand(clap::Command::new("list"))
        .subcommands(O::extra_commands())
    }

    fn augment_subcommands_for_update(cmd: clap::Command) -> clap::Command {
        todo!()
    }
}