/* -*- c++ -*- */
/*
 * Copyright 2003,2005,2011,2013 Free Software Foundation, Inc.
 *
 * This file is part of GNU Radio
 *
 * GNU Radio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 *
 * GNU Radio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GNU Radio; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street,
 * Boston, MA 02110-1301, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <assert.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdexcept>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#include "pagesize.h"
#include "vmcircbuf_createfilemapping.h"
#include <errno.h>
#include <stdio.h>
#include <boost/format.hpp>

namespace gr {

#ifdef HAVE_CREATEFILEMAPPING
// Print Windows error (could/should be global?)
static void werror(char* where, DWORD last_error)
{
    char buf[1024];

    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
                  NULL,
                  last_error,
                  0, // default language
                  buf,
                  sizeof(buf) / sizeof(TCHAR), // buffer size
                  NULL);
    fprintf(stderr, "%s: Error %d: %s", where, last_error, buf);
    return;
}
#endif


vmcircbuf_createfilemapping::vmcircbuf_createfilemapping(int size) : gr::vmcircbuf(size)
{
#if !defined(HAVE_CREATEFILEMAPPING)
    fprintf(stderr, "%s: createfilemapping is not available\n", __FUNCTION__);
    throw std::runtime_error("gr::vmcircbuf_createfilemapping");
#else
    gr::thread::scoped_lock guard(s_vm_mutex);

    static int s_seg_counter = 0;

    if (size <= 0 || (size % gr::pagesize()) != 0) {
        fprintf(stderr, "gr::vmcircbuf_createfilemapping: invalid size = %d\n", size);
        throw std::runtime_error("gr::vmcircbuf_createfilemapping");
    }

    std::string seg_name =
        str(boost::format("/gnuradio-%d-%d") % getpid() % s_seg_counter);

    d_handle = CreateFileMapping(INVALID_HANDLE_VALUE, // use paging file
                                 NULL,                 // default security
                                 PAGE_READWRITE,       // read/write access
                                 0,                    // max. object size
                                 size,                 // buffer size
                                 seg_name.c_str());    // name of mapping object

    s_seg_counter++;
    if (d_handle == NULL || d_handle == INVALID_HANDLE_VALUE) {
        std::string msg =
            str(boost::format(
                    "gr::vmcircbuf_mmap_createfilemapping: CreateFileMapping [%s]") %
                seg_name);
        werror((char*)msg.c_str(), GetLastError());
        throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping");
    }

    // Allocate virtual memory of the needed size, then free it so we can use it
    LPVOID first_tmp;
    first_tmp = VirtualAlloc(NULL, 2 * size, MEM_RESERVE, PAGE_NOACCESS);
    if (first_tmp == NULL) {
        werror("gr::vmcircbuf_mmap_createfilemapping: VirtualAlloc", GetLastError());
        CloseHandle(d_handle); // cleanup
        throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping");
    }

    if (VirtualFree(first_tmp, 0, MEM_RELEASE) == 0) {
        werror("gr::vmcircbuf_mmap_createfilemapping: VirtualFree", GetLastError());
        CloseHandle(d_handle); // cleanup
        throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping");
    }

    d_first_copy = MapViewOfFileEx((HANDLE)d_handle, // handle to map object
                                   FILE_MAP_WRITE,   // read/write permission
                                   0,
                                   0,
                                   size,
                                   first_tmp);
    if (d_first_copy != first_tmp) {
        werror("gr::vmcircbuf_mmap_createfilemapping: MapViewOfFileEx(1)",
               GetLastError());
        CloseHandle(d_handle); // cleanup
        throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping");
    }

    d_second_copy = MapViewOfFileEx((HANDLE)d_handle, // handle to map object
                                    FILE_MAP_WRITE,   // read/write permission
                                    0,
                                    0,
                                    size,
                                    (char*)first_tmp +
                                        size); //(LPVOID) ((char *)d_first_copy + size));

    if (d_second_copy != (char*)first_tmp + size) {
        werror("gr::vmcircbuf_mmap_createfilemapping: MapViewOfFileEx(2)",
               GetLastError());
        UnmapViewOfFile(d_first_copy);
        CloseHandle(d_handle); // cleanup
        throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping");
    }

#ifdef DEBUG
    fprintf(stderr,
            "gr::vmcircbuf_mmap_createfilemapping: contiguous? mmap %p %p %p %p\n",
            (char*)d_first_copy,
            (char*)d_second_copy,
            size,
            (char*)d_first_copy + size);
#endif

    // Now remember the important stuff
    d_base = (char*)d_first_copy;
    d_size = size;
#endif /*HAVE_CREATEFILEMAPPING*/
}

vmcircbuf_createfilemapping::~vmcircbuf_createfilemapping()
{
#ifdef HAVE_CREATEFILEMAPPING
    gr::thread::scoped_lock guard(s_vm_mutex);

    if (UnmapViewOfFile(d_first_copy) == 0) {
        werror("gr::vmcircbuf_createfilemapping: UnmapViewOfFile(d_first_copy)",
               GetLastError());
    }
    d_base = NULL;
    if (UnmapViewOfFile(d_second_copy) == 0) {
        werror("gr::vmcircbuf_createfilemapping: UnmapViewOfFile(d_second_copy)",
               GetLastError());
    }
    // d_second=NULL;
    CloseHandle(d_handle);
#endif
}

// ----------------------------------------------------------------
//      The factory interface
// ----------------------------------------------------------------

gr::vmcircbuf_factory* vmcircbuf_createfilemapping_factory::s_the_factory = 0;

gr::vmcircbuf_factory* vmcircbuf_createfilemapping_factory::singleton()
{
    if (s_the_factory)
        return s_the_factory;
    s_the_factory = new vmcircbuf_createfilemapping_factory();
    return s_the_factory;
}

int vmcircbuf_createfilemapping_factory::granularity()
{
#ifdef HAVE_CREATEFILEMAPPING
    //  return 65536;//TODO, check, is this needed or can we just use gr::pagesize()
    SYSTEM_INFO system_info;
    GetSystemInfo(&system_info);
    // fprintf(stderr,"win32 AllocationGranularity
    // %p\n",(int)system_info.dwAllocationGranularity);
    return (int)system_info.dwAllocationGranularity;
#else
    return gr::pagesize();
#endif
}

gr::vmcircbuf* vmcircbuf_createfilemapping_factory::make(int size)
{
    try {
        return new vmcircbuf_createfilemapping(size);
    } catch (...) {
        return 0;
    }
}

} /* namespace gr */
