/* ## Sections in FLASH */
/* ### Vector table */
.vector_table ORIGIN(FLASH) :
{
  __vector_table = .;
  /* Initial Stack Pointer (SP) value.
   * We mask the bottom three bits to force 8-byte alignment.
   * Despite having an assert for this later, it's possible that a separate
   * linker script could override _stack_start after the assert is checked.
   */
  LONG(_stack_start & 0xFFFFFFF8);
  /* Reset vector */
  KEEP(*(.vector_table.reset_vector)); /* this is the `__RESET_VECTOR` symbol */
  /* Exceptions */
  __exceptions = .; /* start of exceptions */
  KEEP(*(.vector_table.exceptions)); /* this is the `__EXCEPTIONS` symbol */
  __eexceptions = .; /* end of exceptions */
  /* Device specific interrupts */
  KEEP(*(.vector_table.interrupts)); /* this is the `__INTERRUPTS` symbol */
} > FLASH

PROVIDE(NonMaskableInt = DefaultHandler);
PROVIDE(MemoryManagement = DefaultHandler);
PROVIDE(BusFault = DefaultHandler);
PROVIDE(UsageFault = DefaultHandler);
PROVIDE(SecureFault = DefaultHandler);
PROVIDE(SVCall = DefaultHandler);
PROVIDE(DebugMonitor = DefaultHandler);
PROVIDE(PendSV = DefaultHandler);
PROVIDE(SysTick = DefaultHandler);

#[inline(always)]
pub fn run<F>(priority: u8, f: F)
where
    F: FnOnce(),
{
    if priority == 1 {
        // If the priority of this interrupt is `1` then BASEPRI can only be `0`
        f();
        unsafe { basepri::write(0) }
    } else {
        let initial = basepri::read();
        f();
        unsafe { basepri::write(initial) }
    }
}

#[task(binds = SPI3)]
fn hw_task(_cx: hw_task::Context) {
    print!("hello world");
}

#[no_mangle]
unsafe fn SPI3() {
    const PRIORITY: u8 = 1u8;
    rtic::export::run(PRIORITY, || hw_task(hw_task::Context::new()));
}
fn hw_task(_cx: hw_task::Context) {
    print!("hello world");
}

/// Executor for an async task.
pub struct AsyncTaskExecutor<F: Future> {
    // `task` is protected by the `running` flag.
    task: UnsafeCell<MaybeUninit<F>>,
    running: AtomicBool,
    pending: AtomicBool,
}

impl<F: Future> AsyncTaskExecutor<F> {
    /// Poll the future in the executor.
    #[inline(always)]
    pub fn poll(&self, wake: fn()) {
        if self.is_running() && self.check_and_clear_pending() {
            let waker = unsafe { Waker::from_raw(RawWaker::new(wake as *const (), &WAKER_VTABLE)) };
            let mut cx = Context::from_waker(&waker);
            let future = unsafe { Pin::new_unchecked(&mut *(self.task.get() as *mut F)) };

            match future.poll(&mut cx) {
                Poll::Ready(_) => {
                    self.running.store(false, Ordering::Release);
                }
                Poll::Pending => {}
            }
        }
    }
}

/// Pointer to executor holder.
pub struct AsyncTaskExecutorPtr {
    // Void pointer.
    ptr: AtomicPtr<()>,
}
impl AsyncTaskExecutorPtr {
    pub const fn new() -> Self {
        Self {
            ptr: AtomicPtr::new(core::ptr::null_mut()),
        }
    }
}

// Generate executor definition and priority in global scope
for (name, _) in app.software_tasks.iter() {
    let exec_name = util::internal_task_ident(name, "EXEC");
    items.push(quote!(
        #[allow(non_upper_case_globals)]
        static #exec_name: rtic::export::executor::AsyncTaskExecutorPtr =
            rtic::export::executor::AsyncTaskExecutorPtr::new();
    ));
}

impl AsyncTaskExecutorPtr {
    #[inline(always)]
    pub fn set_in_main<F: Future>(&self, executor: &ManuallyDrop<AsyncTaskExecutor<F>>) {
        self.ptr.store(executor as *const _ as _, Ordering::Relaxed);
    }
}

for (name, _) in app.software_tasks.iter() {
    let exec_name = util::internal_task_ident(name, "EXEC");
    let new_n_args = util::new_n_args_ident(app.software_tasks[name].inputs.len());
    executor_allocations.push(quote!(
        let executor = ::core::mem::ManuallyDrop::new(rtic::export::executor::AsyncTaskExecutor::#new_n_args(#name));
        executors_size += ::core::mem::size_of_val(&executor);
        #exec_name.set_in_main(&executor);
    ));
}

#[no_mangle]
unsafe extern "C" fn main() -> ! { /* ... */}

quote!(
    #(#extra_mods_stmts)*
    #[doc(hidden)]
    #[no_mangle]
    unsafe extern "C" fn #main() -> ! {
        #(#assertion_stmts)*
        #(#pre_init_stmts)*
        #[inline(never)]
        fn __rtic_init_resources<F>(f: F) where F: FnOnce() {
            f();
        }
        // Generate allocations for async executors.
        let mut executors_size = 0;
        #(#executor_allocations)*
        #(#msp_check)*
        // Wrap late_init_stmts in a function to ensure that stack space is reclaimed.
        __rtic_init_resources(||{
            let (shared_resources, local_resources) = #init_name(#init_name::Context::new(#init_args));
            #(#post_init_stmts)*
        });
        #call_idle
    }
)

// check that dispatchers are not used as hardware tasks
for task in app.hardware_tasks.values() {
    let binds = &task.args.binds;
    if app.args.dispatchers.contains_key(binds) {
        return Err(parse::Error::new(
            binds.span(),
            "dispatcher interrupts can't be used as hardware tasks",
        ));
    }
}

let mut channels = Channels::new();
for (name, spawnee) in &app.software_tasks {
    let spawnee_prio = spawnee.args.priority;
    let channel = channels.entry(spawnee_prio).or_default();
    channel.tasks.insert(name.clone());
    // All inputs are send as we do not know from where they may be spawned.
    spawnee.inputs.iter().for_each(|input| {
        send_types.insert(input.ty.clone());
    });
}

let doc = format!("Interrupt handler to dispatch async tasks at priority {level}");
let attribute = &interrupts.get(&level).expect("UNREACHABLE").1.attrs;
let config = handler_config(app, analysis, dispatcher_name.clone());
items.push(quote!(
    #[allow(non_snake_case)]
    #[doc = #doc]
    #[no_mangle]
    #(#attribute)*
    #(#config)*
    unsafe fn #dispatcher_name() {
        /// The priority of this interrupt handler
        const PRIORITY: u8 = #level;
        rtic::export::run(PRIORITY, || {
            #(#stmts)*
        });
    }
));

for name in channel.tasks.iter() {
    let exec_name = util::internal_task_ident(name, "EXEC");
    let from_ptr_n_args =
        util::from_ptr_n_args_ident(app.software_tasks[name].inputs.len());
    stmts.push(quote!(
        let exec = rtic::export::executor::AsyncTaskExecutor::#from_ptr_n_args(#name, &#exec_name);
        exec.poll(|| {
            let exec = rtic::export::executor::AsyncTaskExecutor::#from_ptr_n_args(#name, &#exec_name);
            exec.set_pending();
            #pend_interrupt
        });
    ));
}

let pend_interrupt = if level > 0 {
    let int_mod = interrupt_mod(app);
    quote!(rtic::export::pend(#int_mod::#dispatcher_name);)
} else {
    // For 0 priority tasks we don't need to pend anything
    quote!()
};

/// Sets the given `interrupt` as pending
///
/// This is a convenience function around
/// [`NVIC::pend`](../cortex_m/peripheral/struct.NVIC.html#method.pend)
pub fn pend<I>(interrupt: I)
where
    I: InterruptNumber,
{
    NVIC::pend(interrupt);
}

// Check 0-priority async software tasks and idle dependency
for (name, task) in &app.software_tasks {
    if task.args.priority == 0 {
        // If there is a 0-priority task, there must be no idle
        if app.idle.is_some() {
            error.push(syn::Error::new(
                name.span(),
                format!(
                    "Async task {:?} has priority 0, but `#[idle]` is defined. 0-priority async tasks are only allowed if there is no `#[idle]`.",
                    name.to_string(),
                )
            ));
        }
    }
}

let call_idle = if let Some(idle) = &app.idle {
    let name = &idle.name;
    quote!(#name(#name::Context::new()))
} else if analysis.channels.get(&0).is_some() {
    let dispatcher = util::zero_prio_dispatcher_ident();
    quote!(#dispatcher();)
} else {
    quote!(loop {})
};

if level > 0 {
    // generate code for non-zero dispatcher
} else {
    items.push(quote!(
        #[allow(non_snake_case)]
        unsafe fn #dispatcher_name() -> ! {
            loop {
                #(#stmts)*
            }
        }
    ));
}

#[shared]
struct Shared {
    shared1: u32,
    shared2: u32,
}

#[local]
struct Local {
    foo_local_res_1: u32,
    bar_local_res_1: u32,
}

// Check that lock_free resources are correct
for lf_res in lock_free.iter() {
    for (task, tr, _, priority) in task_resources_list.iter() {
        for r in tr {
            // Get all uses of resources annotated lock_free
            if lf_res == r {
                // Check so async tasks do not use lock free resources
                if app.software_tasks.get(task).is_some() {
                    error.push(syn::Error::new(
                        r.span(),
                        format!(
                            "Lock free shared resource {:?} is used by an async tasks, which is forbidden",
                            r.to_string(),
                        ),
                    ));
                }
                // HashMap returns the previous existing object if old.key == new.key
                if let Some(lf_res) = lf_hash.insert(
                    r.to_string(), 
                    (task, r, priority)
                ) {
                    // Check if priority differ, if it does, append to
                    // list of resources which will be annotated with errors
                    if priority != lf_res.2 {
                        lf_res_with_error.push(lf_res.1);
                        lf_res_with_error.push(r);
                    }
                    // If the resource already violates lock free properties
                    if lf_res_with_error.contains(&r) {
                        lf_res_with_error.push(lf_res.1);
                        lf_res_with_error.push(r);
                    }
                }
            }
        }
    }
}

#[inline(always)]
pub unsafe fn lock<T, R>(
    ptr: *mut T,
    ceiling: u8,
    nvic_prio_bits: u8,
    f: impl FnOnce(&mut T) -> R,
) -> R {
    if ceiling == (1 << nvic_prio_bits) {
        critical_section::with(|_| f(&mut *ptr))
    } else {
        let current = basepri::read();
        basepri_max::write(cortex_logical2hw(ceiling, nvic_prio_bits));
        let r = f(&mut *ptr);
        basepri::write(current);
        r
    }
}

    /// Generates a `Mutex` implementation
    #[allow(clippy::too_many_arguments)]
    pub fn impl_mutex(
        app: &App,
        _analysis: &CodegenAnalysis,
        cfgs: &[Attribute],
        resources_prefix: bool,
        name: &Ident,
        ty: &TokenStream2,
        ceiling: u8,
        ptr: &TokenStream2,
    ) -> TokenStream2 {
        let path = if resources_prefix {
            quote!(shared_resources::#name)
        } else {
            quote!(#name)
        };

        let device = &app.args.device;
        quote!(
            #(#cfgs)*
            impl<'a> rtic::Mutex for #path<'a> {
                type T = #ty;

                #[inline(always)]
                fn lock<RTIC_INTERNAL_R>(&mut self, f: impl FnOnce(&mut #ty) -> RTIC_INTERNAL_R) -> RTIC_INTERNAL_R {
                    /// Priority ceiling
                    const CEILING: u8 = #ceiling;

                    unsafe {
                        rtic::export::lock(
                            #ptr,
                            CEILING,
                            #device::NVIC_PRIO_BITS,
                            f,
                        )
                    }
                }
            }
        )
    }

#[proc_macro_attribute]
pub fn app(_args: TokenStream, _input: TokenStream) -> TokenStream {
    let (mut app, analysis) = match syntax::parse(_args, _input) {
        Err(e) => return e.to_compile_error().into(),
        Ok(x) => x,
    };
    // Modify app based on backend before continuing
    if let Err(e) = preprocess::app(&mut app, &analysis) {
        return e.to_compile_error().into();
    }
    let app = app;
    // App is not mutable after this point
    if let Err(e) = check::app(&app, &analysis) {
        return e.to_compile_error().into();
    }
    let analysis = analyze::app(analysis, &app);
    let ts = codegen::app(&app, &analysis);
    // write to disk ...
}

pub struct App {
    /// The arguments to the `#[app]` attribute
    pub args: AppArgs,
    /// The name of the `const` item on which the `#[app]` attribute has been placed
    pub name: Ident,
    /// The `#[init]` function
    pub init: Init,
    /// The `#[idle]` function
    pub idle: Option<Idle>,
    /// Resources shared between tasks defined in `#[shared]`
    pub shared_resources: Map<SharedResource>,
    pub shared_resources_vis: syn::Visibility,
    /// Task local resources defined in `#[local]`
    pub local_resources: Map<LocalResource>,
    pub local_resources_vis: syn::Visibility,
    /// User imports
    pub user_imports: Vec<ItemUse>,
    /// User code
    pub user_code: Vec<Item>,
    /// Hardware tasks: `#[task(binds = ..)]`s
    pub hardware_tasks: Map<HardwareTask>,
    /// Async software tasks: `#[task]`
    pub software_tasks: Map<SoftwareTask>,
}

pub enum Access {
    /// `[x]`, a mutable resource
    Exclusive,
    /// `[&x]`, a static non-mutable resource
    Shared,
}

let (access, path) = match e {
    Expr::Path(e) => (Access::Exclusive, e.path),
    Expr::Reference(ref r) if r.mutability.is_none() => match &*r.expr {
        Expr::Path(e) => (Access::Shared, e.path.clone()),
        _ => return err,
    },
    _ => return err,
};

pub enum Ownership {
    /// Owned by a single task
    Owned {
        /// Priority of the task that owns this resource
        priority: u8,
    },
    /// "Co-owned" by more than one task; all of them have the same priority
    CoOwned {
        /// Priority of the tasks that co-own this resource
        priority: u8,
    },
    /// Contended by more than one task; the tasks have different priorities
    Contended {
        /// Priority ceiling
        ceiling: u8,
    },
}

let mut used_shared_resource = IndexSet::new();
let mut ownerships = Ownerships::new();
let mut sync_types = SyncTypes::new();
for (prio, name, access) in app.shared_resource_accesses() {
    let res = app.shared_resources.get(name).expect("UNREACHABLE");
    // This shared resource is used
    used_shared_resource.insert(name.clone());
    if let Some(priority) = prio {
        if let Some(ownership) = ownerships.get_mut(name) {
            match *ownership {
                Ownership::Owned { priority: ceiling }
                | Ownership::CoOwned { priority: ceiling }
                | Ownership::Contended { ceiling }
                    if priority != ceiling =>
                {
                    *ownership = Ownership::Contended {
                        ceiling: cmp::max(ceiling, priority),
                    };
                    if access.is_shared() {
                        sync_types.insert(res.ty.clone());
                    }
                }
                Ownership::Owned { priority: ceil } if ceil == priority => {
                    *ownership = Ownership::CoOwned { priority };
                }
                _ => {}
            }
        } else {
            ownerships.insert(name.clone(), Ownership::Owned { priority });
        }
    }
}

for (&priority, name) in interrupt_ids.chain(app.hardware_tasks.values().filter_map(|task| {
       if is_exception(&task.args.binds) {
           // We do exceptions in another pass
           None
       } else {
           Some((&task.args.priority, &task.args.binds))
       }
   })) {
       stmts.push(quote!(
           core.NVIC.set_priority(
               #rt_err::#interrupt::#name,
               rtic::export::cortex_logical2hw(#priority, #nvic_prio_bits),
           );
       ));
       // NOTE unmask the interrupt *after* setting its priority: changing the priority of a pended
       // interrupt is implementation defined
       stmts.push(quote!(rtic::export::NVIC::unmask(#rt_err::#interrupt::#name);));
   }

// Set exception priorities
for (name, priority) in app.hardware_tasks.values().filter_map(|task| {
    if is_exception(&task.args.binds) {
        Some((&task.args.binds, task.args.priority))
    } else {
        None
    }
}) {
    stmts.push(quote!(core.SCB.set_priority(
        rtic::export::SystemHandler::#name,
        rtic::export::cortex_logical2hw(#priority, #nvic_prio_bits),
    );));
}

for (name, _) in app.software_tasks.iter() {
    let exec_name = util::internal_task_ident(name, "EXEC");
    let new_n_args = util::new_n_args_ident(app.software_tasks[name].inputs.len());
    executor_allocations.push(quote!(
        let executor = ::core::mem::ManuallyDrop::new(rtic::export::executor::AsyncTaskExecutor::#new_n_args(#name));
        executors_size += ::core::mem::size_of_val(&executor);
        #exec_name.set_in_main(&executor);
    ));
}

#[inline(never)]
fn __rtic_init_resources<F>(f: F) where F: FnOnce() {
    f();
}
// Wrap late_init_stmts in a function to ensure that stack space is reclaimed.
__rtic_init_resources(||{
    let (shared_resources, local_resources) = #init_name(#init_name::Context::new(#init_args));
    #(#post_init_stmts)*
});

/// Generates code that runs after `#[init]` returns
pub fn codegen(app: &App, analysis: &Analysis) -> Vec<TokenStream2> {
    let mut stmts = vec![];

    // Initialize shared resources
    for (name, res) in &app.shared_resources {
        let mangled_name = util::static_shared_resource_ident(name);
        // If it's live
        let cfgs = res.cfgs.clone();
        if analysis.shared_resources.get(name).is_some() {
            stmts.push(quote!(
                // We include the cfgs
                #(#cfgs)*
                // Resource is a RacyCell<MaybeUninit<T>>
                // - `get_mut` to obtain a raw pointer to `MaybeUninit<T>`
                // - `write` the defined value for the late resource T
                #mangled_name.get_mut().write(core::mem::MaybeUninit::new(shared_resources.#name));
            ));
        }
    }

    // Initialize local resources
    for (name, res) in &app.local_resources {
        let mangled_name = util::static_local_resource_ident(name);
        // If it's live
        let cfgs = res.cfgs.clone();
        if analysis.local_resources.get(name).is_some() {
            stmts.push(quote!(
                // We include the cfgs
                #(#cfgs)*
                // Resource is a RacyCell<MaybeUninit<T>>
                // - `get_mut` to obtain a raw pointer to `MaybeUninit<T>`
                // - `write` the defined value for the late resource T
                #mangled_name.get_mut().write(core::mem::MaybeUninit::new(local_resources.#name));
            ));
        }
    }

    // Enable the interrupts -- this completes the `init`-ialization phase
    stmts.push(quote!(rtic::export::interrupt::enable();));

    stmts
}