/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include <assert.h>
#include <string.h>
#include <stdint.h>

#include "os/mynewt.h"

#if (MYNEWT_VAL(OC_TRANSPORT_IP) == 1) && (MYNEWT_VAL(OC_TRANSPORT_IPV4) == 1)
#include <log/log.h>
#include <mn_socket/mn_socket.h>
#include <stats/stats.h>

#include "oic/oc_log.h"
#include "oic/port/oc_connectivity.h"
#include "oic/port/mynewt/adaptor.h"
#include "oic/port/mynewt/transport.h"
#include "oic/port/mynewt/ip.h"

static void oc_send_buffer_ip4(struct os_mbuf *m);
static void oc_send_buffer_ip4_mcast(struct os_mbuf *m);
static uint8_t oc_ep_ip4_size(const struct oc_endpoint *oe);
static char *oc_log_ep_ip4(char *ptr, int maxlen, const struct oc_endpoint *);
static int oc_connectivity_init_ip4(void);
void oc_connectivity_shutdown_ip4(void);
static void oc_event_ip4(struct os_event *ev);

static const struct oc_transport oc_ip4_transport = {
    .ot_flags = 0,
    .ot_ep_size = oc_ep_ip4_size,
    .ot_tx_ucast = oc_send_buffer_ip4,
    .ot_tx_mcast = oc_send_buffer_ip4_mcast,
    .ot_get_trans_security = NULL,
    .ot_ep_str = oc_log_ep_ip4,
    .ot_init = oc_connectivity_init_ip4,
    .ot_shutdown = oc_connectivity_shutdown_ip4
};

static struct os_event oc_sock4_read_event = {
    .ev_cb = oc_event_ip4,
};

#define COAP_PORT_UNSECURED (5683)

/* 224.0.1.187 */
static const struct mn_in_addr coap_all_nodes_v4 = {
    .s_addr = htonl(0xe00001bb)
};

STATS_SECT_START(oc_ip4_stats)
    STATS_SECT_ENTRY(iframe)
    STATS_SECT_ENTRY(ibytes)
    STATS_SECT_ENTRY(ierr)
    STATS_SECT_ENTRY(oucast)
    STATS_SECT_ENTRY(omcast)
    STATS_SECT_ENTRY(obytes)
    STATS_SECT_ENTRY(oerr)
STATS_SECT_END
STATS_SECT_DECL(oc_ip4_stats) oc_ip4_stats;
STATS_NAME_START(oc_ip4_stats)
    STATS_NAME(oc_ip4_stats, iframe)
    STATS_NAME(oc_ip4_stats, ibytes)
    STATS_NAME(oc_ip4_stats, ierr)
    STATS_NAME(oc_ip4_stats, oucast)
    STATS_NAME(oc_ip4_stats, omcast)
    STATS_NAME(oc_ip4_stats, obytes)
    STATS_NAME(oc_ip4_stats, oerr)
STATS_NAME_END(oc_ip4_stats)

/* sockets to use for coap unicast and multicast */
static struct mn_socket *oc_ucast4;

#if (MYNEWT_VAL(OC_SERVER) == 1)
static struct mn_socket *oc_mcast4;
#endif

#ifdef OC_SECURITY
#error This implementation does not yet support security
#endif

static char *
oc_log_ep_ip4(char *ptr, int maxlen, const struct oc_endpoint *oe)
{
    const struct oc_endpoint_ip *oe_ip = (const struct oc_endpoint_ip *)oe;
    int len;

    mn_inet_ntop(MN_PF_INET, oe_ip->v4.address, ptr, maxlen);
    len = strlen(ptr);
    snprintf(ptr + len, maxlen - len, "-%u", oe_ip->port);
    return ptr;
}

static uint8_t
oc_ep_ip4_size(const struct oc_endpoint *oe)
{
    return sizeof(struct oc_endpoint_ip);
}

static void
oc_send_buffer_ip4_int(struct os_mbuf *m, int is_mcast)
{
    struct mn_sockaddr_in to;
    struct oc_endpoint_ip *oe_ip;
    struct mn_itf itf;
    uint32_t if2_idx;
    struct os_mbuf *n;
    int rc;

    assert(OS_MBUF_USRHDR_LEN(m) >= sizeof(struct oc_endpoint_ip));
    oe_ip = (struct oc_endpoint_ip *)OC_MBUF_ENDPOINT(m);
    to.msin_len = sizeof(to);
    to.msin_family = MN_AF_INET;
    to.msin_port = htons(oe_ip->port);
    memcpy(&to.msin_addr, oe_ip->v4.address, sizeof(to.msin_addr));

    STATS_INCN(oc_ip4_stats, obytes, OS_MBUF_PKTLEN(m));
    if (is_mcast) {
        memset(&itf, 0, sizeof(itf));
        if2_idx = 0;

        while (1) {
            rc = mn_itf_getnext(&itf);
            if (rc) {
                break;
            }

            if ((itf.mif_flags & (MN_ITF_F_UP | MN_ITF_F_MULTICAST)) !=
              (MN_ITF_F_UP | MN_ITF_F_MULTICAST)) {
                continue;
            }

            if (!if2_idx) {
                if2_idx = itf.mif_idx;
                continue;
            }

            rc = mn_setsockopt(oc_ucast4, MN_SO_LEVEL, MN_MCAST_IF, &if2_idx);
            if (rc) {
                STATS_INC(oc_ip4_stats, oerr);
                continue;
            }
            n = os_mbuf_dup(m);
            if (!n) {
                STATS_INC(oc_ip4_stats, oerr);
                break;
            }
            rc = mn_sendto(oc_ucast4, n, (struct mn_sockaddr *)&to);
            if (rc != 0) {
                OC_LOG(ERROR, "Failed to send buffer %u on %x\n",
                             OS_MBUF_PKTHDR(m)->omp_len, if2_idx);
                STATS_INC(oc_ip4_stats, oerr);
                os_mbuf_free_chain(n);
            }
            if2_idx = itf.mif_idx;
        }
        if (if2_idx) {
            rc = mn_setsockopt(oc_ucast4, MN_SO_LEVEL, MN_MCAST_IF, &if2_idx);
            if (rc) {
                STATS_INC(oc_ip4_stats, oerr);
                os_mbuf_free_chain(m);
            } else {
                rc = mn_sendto(oc_ucast4, m, (struct mn_sockaddr *) &to);
                if (rc != 0) {
                    OC_LOG(ERROR, "Failed sending buffer %u on itf %x\n",
                                 OS_MBUF_PKTHDR(m)->omp_len, if2_idx);
                    STATS_INC(oc_ip4_stats, oerr);
                    os_mbuf_free_chain(m);
                }
            }
        } else {
            os_mbuf_free_chain(m);
        }
    } else {
        rc = mn_sendto(oc_ucast4, m, (struct mn_sockaddr *) &to);
        if (rc != 0) {
            OC_LOG(ERROR, "Failed to send buffer %u ucast\n",
                         OS_MBUF_PKTHDR(m)->omp_len);
            STATS_INC(oc_ip4_stats, oerr);
            os_mbuf_free_chain(m);
        }
    }
}

void
oc_send_buffer_ip4(struct os_mbuf *m)
{
    STATS_INC(oc_ip4_stats, oucast);
    oc_send_buffer_ip4_int(m, 0);
}
void
oc_send_buffer_ip4_mcast(struct os_mbuf *m)
{
    STATS_INC(oc_ip4_stats, omcast);
    oc_send_buffer_ip4_int(m, 1);
}

static struct os_mbuf *
oc_attempt_rx_ip4_sock(struct mn_socket *rxsock)
{
    int rc;
    struct os_mbuf *m;
    struct os_mbuf *n;
    struct oc_endpoint_ip *oe_ip;
    struct mn_sockaddr_in from;

    rc = mn_recvfrom(rxsock, &n, (struct mn_sockaddr *) &from);
    if (rc != 0) {
        return NULL;
    }
    assert(OS_MBUF_IS_PKTHDR(n));

    STATS_INC(oc_ip4_stats, iframe);
    STATS_INCN(oc_ip4_stats, ibytes, OS_MBUF_PKTLEN(n));
    m = os_msys_get_pkthdr(0, sizeof(struct oc_endpoint_ip));
    if (!m) {
        OC_LOG(ERROR, "Could not allocate RX buffer\n");
        goto rx_attempt_err;
    }
    OS_MBUF_PKTHDR(m)->omp_len = OS_MBUF_PKTHDR(n)->omp_len;
    SLIST_NEXT(m, om_next) = n;

    oe_ip = (struct oc_endpoint_ip *)OC_MBUF_ENDPOINT(m);

    oe_ip->ep.oe_type = oc_ip4_transport_id;
    oe_ip->ep.oe_flags = 0;
    memcpy(&oe_ip->v4.address, &from.msin_addr, sizeof(oe_ip->v4.address));
    oe_ip->port = ntohs(from.msin_port);

    return m;

    /* add the addr info to the message */
rx_attempt_err:
    STATS_INC(oc_ip4_stats, ierr);
    os_mbuf_free_chain(n);
    return NULL;
}

static struct os_mbuf *
oc_attempt_rx_ip4(void)
{
    struct os_mbuf *m;

    m = oc_attempt_rx_ip4_sock(oc_ucast4);
#if (MYNEWT_VAL(OC_SERVER) == 1)
    if (m == NULL) {
        m = oc_attempt_rx_ip4_sock(oc_mcast4);
    }
#endif
    return m;
}

static void oc_socks4_readable(void *cb_arg, int err);

union mn_socket_cb oc_sock4_cbs = {
    .socket.readable = oc_socks4_readable,
    .socket.writable = NULL
};

void
oc_socks4_readable(void *cb_arg, int err)
{
    os_eventq_put(oc_evq_get(), &oc_sock4_read_event);
}

void
oc_connectivity_shutdown_ip4(void)
{
    if (oc_ucast4) {
        mn_close(oc_ucast4);
    }

#if (MYNEWT_VAL(OC_SERVER) == 1)
    if (oc_mcast4) {
        mn_close(oc_mcast4);
    }
#endif
}

static void
oc_event_ip4(struct os_event *ev)
{
    struct os_mbuf *m;

    while ((m = oc_attempt_rx_ip4()) != NULL) {
        oc_recv_message(m);
    }
}

int
oc_connectivity_init_ip4(void)
{
    int rc;
    struct mn_sockaddr_in sin;
    struct mn_itf itf;

    memset(&itf, 0, sizeof(itf));

    rc = mn_socket(&oc_ucast4, MN_PF_INET, MN_SOCK_DGRAM, 0);
    if (rc != 0 || !oc_ucast4) {
        OC_LOG(ERROR, "Could not create oc unicast v4 socket\n");
        return rc;
    }
    mn_socket_set_cbs(oc_ucast4, oc_ucast4, &oc_sock4_cbs);

#if (MYNEWT_VAL(OC_SERVER) == 1)
    rc = mn_socket(&oc_mcast4, MN_PF_INET, MN_SOCK_DGRAM, 0);
    if (rc != 0 || !oc_mcast4) {
        mn_close(oc_ucast4);
        OC_LOG(ERROR, "Could not create oc multicast v4 socket\n");
        return rc;
    }
    mn_socket_set_cbs(oc_mcast4, oc_mcast4, &oc_sock4_cbs);
#endif

    sin.msin_len = sizeof(sin);
    sin.msin_family = MN_AF_INET;
    sin.msin_port = 0;
    memset(&sin.msin_addr, 0, sizeof(sin.msin_addr));

    rc = mn_bind(oc_ucast4, (struct mn_sockaddr *)&sin);
    if (rc != 0) {
        OC_LOG(ERROR, "Could not bind oc unicast v4 socket\n");
        goto oc_connectivity_init_err;
    }

#if (MYNEWT_VAL(OC_SERVER) == 1)
    /* Set socket option to join multicast group on all valid interfaces */
    while (1) {
        struct mn_mreq join;

        rc = mn_itf_getnext(&itf);
        if (rc) {
            break;
        }

        if ((itf.mif_flags & (MN_ITF_F_UP | MN_ITF_F_MULTICAST)) !=
          (MN_ITF_F_UP | MN_ITF_F_MULTICAST)) {
            continue;
        }

        memcpy(&join.mm_addr.v4, &coap_all_nodes_v4, sizeof(coap_all_nodes_v4));
        join.mm_idx = itf.mif_idx;
        join.mm_family = MN_AF_INET;

        rc = mn_setsockopt(oc_mcast4, MN_SO_LEVEL, MN_MCAST_JOIN_GROUP, &join);
        if (rc != 0) {
            continue;
        }

        OC_LOG(DEBUG, "Joined Coap v4 mcast group on %s\n", itf.mif_name);
    }

    sin.msin_port = htons(COAP_PORT_UNSECURED);
    rc = mn_bind(oc_mcast4, (struct mn_sockaddr *)&sin);
    if (rc != 0) {
        OC_LOG(ERROR, "Could not bind oc v4 multicast socket\n");
        goto oc_connectivity_init_err;
    }
#endif

    return 0;

oc_connectivity_init_err:
    oc_connectivity_shutdown_ip4();
    return rc;
}

#endif

uint8_t oc_ip4_transport_id = -1;

void
oc_register_ip4(void)
{
#if (MYNEWT_VAL(OC_TRANSPORT_IP) == 1) && (MYNEWT_VAL(OC_TRANSPORT_IPV4) == 1)
    oc_ip4_transport_id = oc_transport_register(&oc_ip4_transport);
#endif
}