/*
 * Copyright (C) 2015 by Multi-Tech Systems
 *
 * This file is part of libmts-io.
 *
 * libmts-io is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * libmts-io 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libmts-io.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*! 
 \file MTS_IO_LockFile.cpp
 \brief A brief description 
 \date Oct 8, 2014
 \author sgodinez

 A more elaborate description
*/

#include <mts/MTS_IO_LockFile.h>
#include <mts/MTS_Timer.h>
#include <mts/MTS_Logger.h>
#include <mts/MTS_System.h>
#include <mts/MTS_Text.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>

using namespace MTS::IO;

LockFile::LockFile(const std::string& sFile)
: m_sFile(sFile)
, m_iLockFd(-1)
{

}

LockFile::~LockFile() {
    unlock();
}

bool LockFile::lock(uint32_t attemptMillis) {
    if(isLocked()) {
        return true;
    }

    MTS::Timer timer;

    timer.start();
    while(timer.getMillis() < attemptMillis) {
        m_iLockFd =::open(m_sFile.c_str(), O_CREAT | O_WRONLY | O_TRUNC | O_EXCL, 0644);
        if (m_iLockFd < 0) {
            // device already locked -> bail out
            printWarning("LockFile| Failed to Lock [%s] [%d][%s]", m_sFile.c_str(), errno, strerror(errno));

            //Check if lock file's process still exists
            std::string sResult;
            if(MTS::System::readFile(m_sFile, sResult) == 0 && sResult.size() > 0) {
                struct stat sts;
                std::string sProc = "/proc/" + MTS::Text::trim(sResult);
                if (stat(sProc.c_str(), &sts) == -1 && errno == ENOENT) {
                    printWarning("LockFile| Current Lock's Process [%s] does not exist.  Removing lock.", sResult.c_str());
                    // process doesn't exist -> remove file
                    ::unlink(m_sFile.c_str());
                }
            }

        } else {
            //TODO: Investigate using flock in addition to minicom-style lock : flock(m_iLockFd, LOCK_EX | LOCK_NB);

            // %4d to make concurrent mgetty (if any) happy.
            // Mgetty treats 4-bytes lock files as binary,
            // not text, PID. Making 5+ char file. Brrr...
            char buf[256] = {0};
            size_t written = 0;

            sprintf(buf, "%4d\n", getpid());
            size_t wsize = strlen(buf);

            written = write(m_iLockFd, buf, wsize);

            if (wsize != written) {
                printError("LockFile| Error writing to lock file [%s] [%d][%s]", m_sFile.c_str(), errno, strerror(errno));
                close(m_iLockFd);
                return false;
            }
            else {
                close(m_iLockFd);
                return true;
            }
        }
        uint32_t randomSleepTime = ((rand() % 10) + 1) * 100000; //Sleep from 100ms to 1 Second
        ::usleep(randomSleepTime);
    }
    return false;
}

void LockFile::unlock() {
    if(isLocked()) {
        ::unlink(m_sFile.c_str());
        //TODO: flock cleanup : flock(m_iLockFd, LOCK_UN);
        m_iLockFd = -1;
    }
}

bool LockFile::isLocked() {
    return m_iLockFd >= 0;
}