/*
 * Copyright (c) 2015 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libc
 * @{
 */
/** @file Universaly Unique Identifier (see RFC 4122)
 */

#include <errno.h>
#include <uuid.h>
#include <rndgen.h>
#include <stdlib.h>
#include <stddef.h>
#include <str.h>

/** Generate UUID.
 *
 * @param uuid Place to store generated UUID
 * @return EOK on success or an error code
 */
errno_t uuid_generate(uuid_t *uuid)
{
	int i;
	rndgen_t *rndgen;
	errno_t rc;

	rc = rndgen_create(&rndgen);
	if (rc != EOK)
		return EIO;

	for (i = 0; i < uuid_bytes; i++) {
		rc = rndgen_uint8(rndgen, &uuid->b[i]);
		if (rc != EOK) {
			rc = EIO;
			goto error;
		}
	}

	/* Version 4 UUID from random or pseudo-random numbers */
	uuid->b[8] = (uuid->b[8] & ~0xc0) | 0x40;
	uuid->b[6] = (uuid->b[6] & 0xf0) | 0x40;

	return EOK;
error:
	rndgen_destroy(rndgen);
	return rc;
}

/** Encode UUID into binary form per RFC 4122.
 *
 * @param uuid UUID
 * @param buf 16-byte destination buffer
 */
void uuid_encode(uuid_t *uuid, uint8_t *buf)
{
	int i;

	for (i = 0; i < uuid_bytes; i++)
		buf[i] = uuid->b[i];
}

/** Decode UUID from binary form per RFC 4122.
 *
 * @param buf 16-byte source buffer
 * @param uuid Place to store UUID
 */
void uuid_decode(uint8_t *buf, uuid_t *uuid)
{
	int i;

	for (i = 0; i < uuid_bytes; i++)
		uuid->b[i] = buf[i];
}

/** Parse string UUID.
 *
 * If @a endptr is not NULL, it is set to point to the first character
 * following the UUID. If @a endptr is NULL, the string must not contain
 * any characters following the UUID, otherwise an error is returned.
 *
 * @param str    String beginning with UUID string representation
 * @param uuid   Place to store UUID
 * @param endptr Place to store pointer to end of UUID or @c NULL
 *
 * @return EOK on success or an error code
 */
errno_t uuid_parse(const char *str, uuid_t *uuid, const char **endptr)
{
	errno_t rc;
	const char *eptr;
	uint32_t time_low;
	uint16_t time_mid;
	uint16_t time_ver;
	uint16_t clock;
	uint64_t node;
	int i;

	rc = str_uint32_t(str, &eptr, 16, false, &time_low);
	if (rc != EOK || eptr != str + 8 || *eptr != '-')
		return EINVAL;

	rc = str_uint16_t(str + 9, &eptr, 16, false, &time_mid);
	if (rc != EOK || eptr != str + 13 || *eptr != '-')
		return EINVAL;

	rc = str_uint16_t(str + 14, &eptr, 16, false, &time_ver);
	if (rc != EOK || eptr != str + 18 || *eptr != '-')
		return EINVAL;

	rc = str_uint16_t(str + 19, &eptr, 16, false, &clock);
	if (rc != EOK || eptr != str + 23 || *eptr != '-')
		return EINVAL;

	rc = str_uint64_t(str + 24, &eptr, 16, false, &node);
	if (rc != EOK || eptr != str + 36 || *eptr != '\0')
		return EINVAL;

	uuid->b[0] = time_low >> 24;
	uuid->b[1] = (time_low >> 16) & 0xff;
	uuid->b[2] = (time_low >> 8) & 0xff;
	uuid->b[3] = time_low & 0xff;

	uuid->b[4] = time_mid >> 8;
	uuid->b[5] = time_mid & 0xff;

	uuid->b[6] = time_ver >> 8;
	uuid->b[7] = time_ver & 0xff;

	uuid->b[8] = clock >> 8;
	uuid->b[9] = clock & 0xff;

	for (i = 0; i < 6; i++)
		uuid->b[10 + i] = (node >> 8 * (5 - i)) & 0xff;

	if (endptr != NULL) {
		*endptr = str + 36;
	} else {
		if (*(str + 36) != '\0')
			return EINVAL;
	}

	return EOK;
}

/** Format UUID into string representation.
 *
 * @param uuid UUID
 * @param rstr Place to store pointer to newly allocated string
 *
 * @return EOK on success, ENOMEM if out of memory
 */
errno_t uuid_format(uuid_t *uuid, char **rstr)
{
	return ENOTSUP;
}

/** @}
 */
