use core::fmt::{Display, Formatter, Debug};

#[derive(Debug, Copy, Clone)] 
pub enum MethodAccessFlag {
    Public       = 0x0001,    // Declared public; may be accessed from outside its package.
    Private      = 0x0002,    // Declared private; accessible only within the defining class and other classes belonging to the same nest (§5.4.4).
    Protected    = 0x0004,    // Declared protected; may be accessed within subclasses.
    Static       = 0x0008,    // Declared static.
    Final        = 0x0010,    // Declared final; must not be overridden (§5.4.5).
    Synchronized = 0x0020,    // Declared synchronized; invocation is wrapped by a monitor use.
    Bridge       = 0x0040,    // A bridge method, generated by the compiler.
    Varargs      = 0x0080,    // Declared with variable number of arguments.
    Native       = 0x0100,    // Declared native; implemented in a language other than the Java programming language.
    Abstract     = 0x0400,    // Declared abstract; no implementation is provided.
    Strict       = 0x0800,    // In a class file whose major version number is at least 46 and at most 60: Declared strict.
    Synthetic    = 0x1000,    // Declared synthetic; not present in the source code.
}

pub struct MethodAccessFlagMask {
    pub mask: u16,
}

impl Debug for MethodAccessFlagMask {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
        let mut flag_vec = Vec::new();

        let flags = [MethodAccessFlag::Public,MethodAccessFlag::Private,MethodAccessFlag::Protected,MethodAccessFlag::Static,MethodAccessFlag::Final,MethodAccessFlag::Synchronized,MethodAccessFlag::Bridge,MethodAccessFlag::Varargs,MethodAccessFlag::Native,MethodAccessFlag::Abstract,MethodAccessFlag::Strict,MethodAccessFlag::Synthetic];

        for flag in flags {
            if (flag as u16 & self.mask) != 0 {
                flag_vec.push(flag)
            }
        }

        f.debug_list().entries(flag_vec)
            .finish()
    }
}

#[derive(Debug, Copy, Clone)] 
pub enum ClassAccessFlag {
    Public        = 0x0001, //  Declared public; may be accessed from outside its package.
    Final         = 0x0010, //  Declared final; no subclasses allowed.
    Super         = 0x0020, //  Treat superclass methods specially when invoked by the invokespecial instruction.
    Interface     = 0x0200, //  Is an interface, not a class.
    Abstract      = 0x0400, //  Declared abstract; must not be instantiated.
    Synthetic     = 0x1000, //  Declared synthetic; not present in the source code.
    Annotation    = 0x2000, //  Declared as an annotation interface.
    Enum          = 0x4000, //  Declared as an enum class.
    Module        = 0x8000, //  Is a module, not a class or interface.
}

pub struct ClassAccessFlagMask {
    pub mask: u16,
}

impl Debug for ClassAccessFlagMask {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
        let mut flag_vec = Vec::new();

        let flags = [ClassAccessFlag::Public,ClassAccessFlag::Final,ClassAccessFlag::Super,ClassAccessFlag::Interface,ClassAccessFlag::Abstract,ClassAccessFlag::Synthetic,ClassAccessFlag::Annotation,ClassAccessFlag::Enum,ClassAccessFlag::Module];
        for flag in flags {
            if (flag as u16 & self.mask) != 0 {
                flag_vec.push(flag)
            }
        }

        f.debug_list().entries(flag_vec)
            .finish()
    }
}

#[derive(Debug, Clone, Copy)]
#[repr(u16)]
pub enum FieldAccessFlag {
    Public    = 0x0001, // 	Declared public; may be accessed from outside its package.
    Private   = 0x0002, // 	Declared private; accessible only within the defining class and other classes belonging to the same nest (§5.4.4).
    Protected = 0x0004, // 	Declared protected; may be accessed within subclasses.
    Static    = 0x0008, // 	Declared static.
    Final     = 0x0010, // 	Declared final; never directly assigned to after object construction (JLS §17.5).
    Volatile  = 0x0040, // 	Declared volatile; cannot be cached.
    Transient = 0x0080, // 	Declared transient; not written or read by a persistent object manager.
    Synthetic = 0x1000, // 	Declared synthetic; not present in the source code.
    Enum      = 0x4000, // 	Declared as an element of an enum class. 
 }

 pub struct FieldAccessFlagMask {
     pub mask: u16
 }

impl Debug for FieldAccessFlagMask {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
        let mut flag_vec = Vec::new();

        let flags = [FieldAccessFlag::Public,FieldAccessFlag::Private,FieldAccessFlag::Protected,FieldAccessFlag::Static,FieldAccessFlag::Final,FieldAccessFlag::Volatile,FieldAccessFlag::Transient,FieldAccessFlag::Synthetic,FieldAccessFlag::Enum,];

        for flag in flags {
            if (flag as u16 & self.mask) != 0 {
                flag_vec.push(flag)
            }
        }

        f.debug_list().entries(flag_vec)
            .finish()
    }
}