// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use anyhow::{Context as _, Error};
use fuchsia_async as fasync;
use hyper::{Body, Request, Response};
use serde::{Deserialize, Serialize};
use std::convert::Infallible;
use std::future::Future;
use std::net::{IpAddr, SocketAddr};

const SERVER_PORT: u16 = 8880;

pub enum SetupEvent {
    Root,
    DevhostOta { cfg: DevhostConfig },
}

/// Devhost configuration, passed to the actual OTA process.
pub struct DevhostConfig {
    pub url: String,
}

#[derive(Deserialize, Serialize)]
/// Configuration provided by the host for the devhost OTA. Only used for de/serialization.
struct DevhostRequestInfo {
    /// We assume that the OTA server is running on the requester's address
    /// at the given port.
    pub port: u16,
}

async fn parse_ota_json(
    request: Request<Body>,
    remote_addr: IpAddr,
) -> Result<DevhostConfig, Error> {
    use bytes::Buf as _;

    let body = hyper::body::aggregate(request.into_body()).await.context("read request")?;
    let DevhostRequestInfo { port } =
        serde_json::from_reader(body.reader()).context("Failed to parse JSON")?;

    let url = format!("http://{}/config.json", SocketAddr::new(remote_addr, port));
    Ok(DevhostConfig { url })
}

async fn serve<Fut, F>(
    request: Request<Body>,
    remote_addr: SocketAddr,
    handler: F,
) -> Response<Body>
where
    Fut: Future<Output = ()>,
    F: FnOnce(SetupEvent) -> Fut,
{
    use hyper::{Method, StatusCode};

    match (request.method(), request.uri().path()) {
        (&Method::GET, "/") => {
            let () = handler(SetupEvent::Root).await;
            Response::new("Root document".into())
        }
        (&Method::POST, "/ota/devhost") => {
            // get devhost info out of POST request.
            match parse_ota_json(request, remote_addr.ip()).await {
                Err(e) => {
                    let mut response = Response::new(format!("Bad request: {:?}", e).into());
                    *response.status_mut() = StatusCode::BAD_REQUEST;
                    response
                }
                Ok(cfg) => {
                    let () = handler(SetupEvent::DevhostOta { cfg }).await;
                    Response::new("Started OTA".into())
                }
            }
        }
        _ => {
            let mut response = Response::new("Unknown command".into());
            *response.status_mut() = StatusCode::NOT_FOUND;
            response
        }
    }
}

pub fn start_server<Fut, F>(handler: F) -> impl Future<Output = Result<(), hyper::Error>>
where
    Fut: Future<Output = ()>,
    F: FnOnce(SetupEvent) -> Fut,
    Fut: Send + 'static,
    F: Clone + Send + 'static,
{
    use futures::{FutureExt as _, TryStreamExt as _};
    use hyper::service::{make_service_fn, service_fn};

    println!("recovery: start_server");

    let addr = SocketAddr::new(IpAddr::V6(std::net::Ipv6Addr::UNSPECIFIED), SERVER_PORT);
    let listener = fasync::net::TcpListener::bind(&addr).expect("bind");
    let listener = listener
        .accept_stream()
        .map_ok(|(stream, _): (_, SocketAddr)| fuchsia_hyper::TcpStream { stream });

    let make_svc = make_service_fn(move |fuchsia_hyper::TcpStream { stream }| {
        let handler = handler.clone();
        std::future::ready((|| {
            let remote_addr = stream.std().peer_addr().context("peer addr")?;
            Ok::<_, Error>(service_fn(move |request| {
                let handler = handler.clone();
                serve(request, remote_addr, handler).map(Ok::<_, Infallible>)
            }))
        })())
    });

    hyper::Server::builder(hyper::server::accept::from_stream(listener))
        .executor(fuchsia_hyper::Executor)
        .serve(make_svc)
}