#include "client.h"
#include <pcap.h>
#include <pthread.h>
#include <netinet/if_ether.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
/*IOKIT HEADERS*/
#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/network/IOEthernetInterface.h>
#include <IOKit/network/IONetworkInterface.h>
#include <IOKit/network/IOEthernetController.h>
#include <IOKit/IOTypes.h>


#define DEFAULT_PAYLOAD_SIZE MTU_-ETHER_HDR_LEN-((5*32)>>3)/*smallest ip header size*/-16

struct tx_session
{
    FILE *file;
    union {
        uint32_t ip;
        char ip_c[4];
    };
    int port;
    pthread_t thread;
    char *head;
    char *tail;
    char window[SEND_WINDOW_SIZE];
};

static union {uint32_t ip_n; char ip_c[4];} local_ip, local_ip_mask;
static union {uint64_t eth_n; char eth_c[6];} local_eth;
static char *device;
static pcap_t *phandle;
static struct bpf_program *bpf;
unsigned char router_mac[6] = {0xff,0xff,0xff,0xff,0xff,0xff};

static void autoset_device (void);
static struct tx_session *tx_session_(const char *, const char *, int);
static int transmit_t (struct tx_session *);
static int send_arp (void);
static void make_ether_h (uint64_t , uint64_t, u_char *, short);

int send_file_ (const char *fname, const char *destip, int port, char *capture_device)
{
    struct tx_session   *session = NULL;
    char                errbuffer[PCAP_ERRBUF_SIZE];
    device = NULL;
    if (capture_device == NULL)
        autoset_device();
    else
        device = capture_device;
    if (device != NULL)
    {
        if ((bpf = malloc(sizeof(*bpf))) == NULL)
            return -1;
        phandle = pcap_open_live(device, MTU_, 0, TIMEOUT, errbuffer);
    }
    if ((session = tx_session_(fname,destip,port)) == NULL)
        return -1;
    if (pthread_create(&session->thread, NULL, (void *(*)())transmit_t, (void *)session) != 0)
        return -1;
    if (pthread_join(session->thread, NULL) != 0)
        return -1;
    return 0;
}

static void autoset_device (void)
{
    struct ifreq    buffer;
    pcap_if_t       *alldevs = NULL;
    pcap_if_t       *iterator = NULL;
    char            errbuffer[PCAP_ERRBUF_SIZE];
    if (pcap_findalldevs(&alldevs, errbuffer) < 0) {
        perror("ERROR ");
        return;
    }
    if (alldevs == NULL) {
        perror("ERROR");
        return;
    }
    for (iterator = alldevs; iterator->next != NULL; iterator = iterator->next) {
        if (pcap_lookupnet(iterator->name, (bpf_u_int32 *)&local_ip, (bpf_u_int32 *)&local_ip_mask, errbuffer) >= 0)
            break;
    }
    if ((device = malloc(strlen(iterator->name)+1)) == NULL)
        return;
    strcpy (device,iterator->name);
    device[strlen(iterator->name)] = '\0';
    pcap_freealldevs(alldevs);
}

static struct tx_session *tx_session_(const char *fname, const char *destip, int port)
{
    struct tx_session   *newtx = NULL;
    char                ip[4];
    if ((newtx = calloc(1,sizeof(*newtx))) == NULL)
        return NULL;
    if ((newtx->file = fopen(fname,"r")) == NULL) {
        free (newtx);
        return NULL;
    }
    newtx->head = newtx->tail = newtx->window;
    if (sscanf(destip,"%d.%d.%d.%d",(int *)&newtx->ip_c[0],(int *)&newtx->ip_c[1],(int *)&newtx->ip_c[2],(int *)&newtx->ip_c[3]) < 4)
        return NULL;
    newtx->port = port;
    return newtx;
}

static int transmit_t (struct tx_session *session_s)
{
    char    *tx_buffer = NULL;
    int     active = 1;
    size_t  bread;
    u_char  *buffer;
    if ((tx_buffer = calloc(DEFAULT_PAYLOAD_SIZE,sizeof(*tx_buffer))) == NULL)
        return -1;
    if (*(uint64_t *)router_mac == 0xffffffffffff) {
        buffer = malloc(sizeof(struct ether_header)+26/*sizeof arp header?*/);
        //make_ether_h (uint64_t src, uint64_t dest, buffer, ETHERTYPE_ARP);
    }
    printf("%s\n",device);
    while(active) {
        bread = fread(tx_buffer, 1, DEFAULT_PAYLOAD_SIZE, session_s->file);
        if (bread != DEFAULT_PAYLOAD_SIZE) {
            if (feof(session_s->file) != 0) {
                active = 0;
                return 0;
            }
            else {
                free (tx_buffer);
                return -1;
            }
        }
        printf("hey!\n");
    }
}

static void make_ether_h (uint64_t src, uint64_t dest, u_char *buffer, short type)
{
    struct ether_header *header = (struct ether_header *)buffer;
    memcpy(header->ether_dhost, &dest, 6);
    memcpy(header->ether_shost, &src, 6);
    header->ether_type = type;
}

/***************************PASTE OF IOKIT FUNCTIONS FROM EXAMPLE*****************************/

// Returns an iterator containing the primary (built-in) Ethernet interface. The caller is responsible for
// releasing the iterator after the caller is done with it.
static kern_return_t FindEthernetInterfaces(io_iterator_t *matchingServices)
{
    kern_return_t           kernResult;
    CFMutableDictionaryRef  matchingDict;
    CFMutableDictionaryRef  propertyMatchDict;

    // Ethernet interfaces are instances of class kIOEthernetInterfaceClass.
    // IOServiceMatching is a convenience function to create a dictionary with the key kIOProviderClassKey and
    // the specified value.
    matchingDict = IOServiceMatching(kIOEthernetInterfaceClass);

    // Note that another option here would be:
    // matchingDict = IOBSDMatching("en0");
    // but en0: isn't necessarily the primary interface, especially on systems with multiple Ethernet ports.

    if (NULL == matchingDict) {
        printf("IOServiceMatching returned a NULL dictionary.\n");
    }
    else {
        // Each IONetworkInterface object has a Boolean property with the key kIOPrimaryInterface. Only the
        // primary (built-in) interface has this property set to TRUE.

        // IOServiceGetMatchingServices uses the default matching criteria defined by IOService. This considers
        // only the following properties plus any family-specific matching in this order of precedence
        // (see IOService::passiveMatch):
        //
        // kIOProviderClassKey (IOServiceMatching)
        // kIONameMatchKey (IOServiceNameMatching)
        // kIOPropertyMatchKey
        // kIOPathMatchKey
        // kIOMatchedServiceCountKey
        // family-specific matching
        // kIOBSDNameKey (IOBSDNameMatching)
        // kIOLocationMatchKey

        // The IONetworkingFamily does not define any family-specific matching. This means that in
        // order to have IOServiceGetMatchingServices consider the kIOPrimaryInterface property, we must
        // add that property to a separate dictionary and then add that to our matching dictionary
        // specifying kIOPropertyMatchKey.

        propertyMatchDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
                                                      &kCFTypeDictionaryKeyCallBacks,
                                                      &kCFTypeDictionaryValueCallBacks);

        if (NULL == propertyMatchDict) {
            printf("CFDictionaryCreateMutable returned a NULL dictionary.\n");
        }
        else {
            // Set the value in the dictionary of the property with the given key, or add the key
            // to the dictionary if it doesn't exist. This call retains the value object passed in.
            CFDictionarySetValue(propertyMatchDict, CFSTR(kIOPrimaryInterface), kCFBooleanTrue);

            // Now add the dictionary containing the matching value for kIOPrimaryInterface to our main
            // matching dictionary. This call will retain propertyMatchDict, so we can release our reference
            // on propertyMatchDict after adding it to matchingDict.
            CFDictionarySetValue(matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict);
            CFRelease(propertyMatchDict);
        }
    }

    // IOServiceGetMatchingServices retains the returned iterator, so release the iterator when we're done with it.
    // IOServiceGetMatchingServices also consumes a reference on the matching dictionary so we don't need to release
    // the dictionary explicitly.
    kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, matchingServices);
    if (KERN_SUCCESS != kernResult) {
        printf("IOServiceGetMatchingServices returned 0x%08x\n", kernResult);
    }

    return kernResult;
}

// Given an iterator across a set of Ethernet interfaces, return the MAC address of the last one.
// If no interfaces are found the MAC address is set to an empty string.
// In this sample the iterator should contain just the primary interface.
static kern_return_t GetMACAddress(io_iterator_t intfIterator, UInt8 *MACAddress, UInt8 bufferSize)
{
    io_object_t     intfService;
    io_object_t     controllerService;
    kern_return_t   kernResult = KERN_FAILURE;

    // Make sure the caller provided enough buffer space. Protect against buffer overflow problems.
    if (bufferSize < kIOEthernetAddressSize) {
        return kernResult;
    }

    // Initialize the returned address
    bzero(MACAddress, bufferSize);

    // IOIteratorNext retains the returned object, so release it when we're done with it.
    while ((intfService = IOIteratorNext(intfIterator)))
    {
        CFTypeRef   MACAddressAsCFData;

        // IONetworkControllers can't be found directly by the IOServiceGetMatchingServices call,
        // since they are hardware nubs and do not participate in driver matching. In other words,
        // registerService() is never called on them. So we've found the IONetworkInterface and will
        // get its parent controller by asking for it specifically.

        // IORegistryEntryGetParentEntry retains the returned object, so release it when we're done with it.
        kernResult = IORegistryEntryGetParentEntry(intfService,
                                                   kIOServicePlane,
                                                   &controllerService);

        if (KERN_SUCCESS != kernResult) {
            printf("IORegistryEntryGetParentEntry returned 0x%08x\n", kernResult);
        }
        else {
            // Retrieve the MAC address property from the I/O Registry in the form of a CFData
            MACAddressAsCFData = IORegistryEntryCreateCFProperty(controllerService,
                                                                 CFSTR(kIOMACAddress),
                                                                 kCFAllocatorDefault,
                                                                 0);
            if (MACAddressAsCFData) {
                CFShow(MACAddressAsCFData); // for display purposes only; output goes to stderr

                // Get the raw bytes of the MAC address from the CFData
                CFDataGetBytes(MACAddressAsCFData, CFRangeMake(0, kIOEthernetAddressSize), MACAddress);
                CFRelease(MACAddressAsCFData);
            }

            // Done with the parent Ethernet controller object so we release it.
            (void) IOObjectRelease(controllerService);
        }

        // Done with the Ethernet interface object so we release it.
        (void) IOObjectRelease(intfService);
    }

    return kernResult;
}

int main (void)
{
    if (send_file ("../hash.c", "127.0.0.1", 9001) < 0)
        printf("derp err\n");
    return 0;
}