use std::vec::Vec;

#[derive(Copy, Clone)]
pub enum Status {
    Input = 10,
    Success = 20,
    Redirect = 30,
    TemporaryFailure = 40,
    PermanentFailure = 50,
    ClientCertificateRequired = 60,
}

pub struct Header {
    status: Status,
    meta: String,
}

pub struct Response {
    header: Header,
    data: Vec<u8>,
}

impl Header {
    pub fn new(status: Status, meta: &str) -> Header {
        Header {
            status: status,
            meta: meta.to_string(),
        }
    }

    pub fn format(&self) -> String {
        format!("{} {}\r\n", self.status as u8, self.meta)
    }
}

impl Response {
    pub fn new(header: Header, data: Vec<u8>) -> Response {
        Response {
            header: header,
            data: data,
        }
    }

    pub fn new_empty(header: Header) -> Response {
        Response {
            header: header,
            data: Vec::new(),
        }
    }

    pub fn format(&self) -> Vec<u8> {
        let mut resp: Vec<u8> = self.header.format().as_bytes().to_vec();
        resp.extend(&self.data);
        return resp;
    }
}

pub fn invalid_protocol() -> Response {
    Response::new_empty(Header::new(
        Status::PermanentFailure,
        "this protocol is not supported",
    ))
}

pub fn not_understood() -> Response {
    Response::new_empty(Header::new(
        Status::PermanentFailure,
        "request not understood",
    ))
}

pub fn internal_error() -> Response {
    Response::new_empty(Header::new(
        Status::PermanentFailure,
        "internal server error",
    ))
}