/*
 * 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
 * resarding 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 <string.h>
#include "os/mynewt.h"
#include "console/console.h"
#include "shell/shell.h"
#include "hal/hal_gpio.h"
#include "tcs34725/tcs34725.h"
#include "tcs34725_priv.h"
#include "parse/parse.h"

#if MYNEWT_VAL(TCS34725_CLI)
static int tcs34725_shell_cmd(int argc, char **argv);

static struct shell_cmd tcs34725_shell_cmd_struct = {
    .sc_cmd = "tcs34725",
    .sc_cmd_func = tcs34725_shell_cmd
};

static struct sensor_itf g_sensor_itf = {
    .si_type = MYNEWT_VAL(TCS34725_SHELL_ITF_TYPE),
    .si_num = MYNEWT_VAL(TCS34725_SHELL_ITF_NUM),
    .si_addr = MYNEWT_VAL(TCS34725_SHELL_ITF_ADDR)
};

static int
tcs34725_shell_err_too_many_args(char *cmd_name)
{
    console_printf("Error: too many arguments for command \"%s\"\n",
                   cmd_name);
    return SYS_EINVAL;
}

static int
tcs34725_shell_err_unknown_arg(char *cmd_name)
{
    console_printf("Error: unknown argument \"%s\"\n",
                   cmd_name);
    return SYS_EINVAL;
}

static int
tcs34725_shell_err_invalid_arg(char *cmd_name)
{
    console_printf("Error: invalid argument \"%s\"\n",
                   cmd_name);
    return SYS_EINVAL;
}

static int
tcs34725_shell_help(void)
{
    console_printf("%s cmd [flags...]\n", tcs34725_shell_cmd_struct.sc_cmd);
    console_printf("cmd:\n");
    console_printf("\tr    [n_samples]\n");
    console_printf("\tgain [0: 1|1: 4|2: 16|3: 60]\n");
    console_printf("\ttime [0: 2.4|1: 24|2: 50|3: 101|4: 154|5: 700]\n");
    console_printf("\ten   [0|1]\n");
    console_printf("\tint  pin [p_num(0..255)]\n");
    console_printf("\tint  on|off|clr\n");
    console_printf("\tint  set [rate(0..15)] [lower(0..65535)] [upper(0..65535)]\n");
    console_printf("\tdump\n");

    return 0;
}

static int
tcs34725_shell_cmd_read(int argc, char **argv)
{
    uint16_t r;
    uint16_t g;
    uint16_t b;
    uint16_t c;
    uint16_t samples = 1;
    uint16_t val;
    int rc;
    struct tcs34725 tcs34725;
    uint8_t int_time;
    int delay_ticks;

    if (argc > 3) {
        return tcs34725_shell_err_too_many_args(argv[1]);
    }

    /* Check if more than one sample requested */
    if (argc == 3) {
        val = parse_ll_bounds(argv[2], 1, UINT16_MAX, &rc);
        if (rc) {
            return tcs34725_shell_err_invalid_arg(argv[2]);
        }
        samples = (uint16_t)val;
    }

    while(samples--) {

        rc = tcs34725_get_integration_time(&g_sensor_itf, &int_time);
        if (rc) {
            goto err;
        }

        /* Set a delay for the integration time */
        switch (int_time)
        {
            case TCS34725_INTEGRATIONTIME_2_4MS:
                delay_ticks = 3;
                break;
            case TCS34725_INTEGRATIONTIME_24MS:
                delay_ticks = 24;
                break;
            case TCS34725_INTEGRATIONTIME_50MS:
                delay_ticks = 50;
                break;
            case TCS34725_INTEGRATIONTIME_101MS:
                delay_ticks = 101;
                break;
            case TCS34725_INTEGRATIONTIME_154MS:
                delay_ticks = 154;
                break;
            case TCS34725_INTEGRATIONTIME_700MS:
                delay_ticks = 700;
                break;
            default:
                /*
                 * If the integration time specified is not from the config,
                 * it will get considered as valid inetgration time in ms
                 */
                delay_ticks = 700;
                break;
        }

        os_time_delay((delay_ticks * OS_TICKS_PER_SEC)/1000 + 1);

        rc = tcs34725_get_rawdata(&g_sensor_itf, &r, &g, &b, &c, &tcs34725);
        if (rc) {
            goto err;
        }

        console_printf("r: %u g: %u b: %u c: %u \n", r, g, b, c);
    }

    return 0;
err:
    console_printf("Read failed: %d\n", rc);
    return rc;
}


static int
tcs34725_shell_cmd_gain(int argc, char **argv)
{
    uint8_t val;
    uint8_t gain;
    int rc;

    if (argc > 3) {
        return tcs34725_shell_err_too_many_args(argv[1]);
    }

    /* Display the gain */
    if (argc == 2) {
        rc = tcs34725_get_gain(&g_sensor_itf, &gain);
        if (rc) {
            goto err;
        }
        console_printf("\tgain [0: 1|1: 4|2: 16|3: 60]\n");
        console_printf("%u\n", gain);
    }

    /* Update the gain */
    if (argc == 3) {
        val = parse_ll_bounds(argv[2], 0, 3, &rc);
        if (rc) {
            return tcs34725_shell_err_invalid_arg(argv[2]);
        }
        rc = tcs34725_set_gain(&g_sensor_itf, val);
        if (rc) {
            goto err;
        }
    }

    return 0;
err:
    return rc;
}


static int
tcs34725_shell_cmd_time(int argc, char **argv)
{
    uint8_t time;
    uint8_t val;
    int rc;

    if (argc > 3) {
        return tcs34725_shell_err_too_many_args(argv[1]);
    }

    /* Display the integration time */
    if (argc == 2) {
        rc = tcs34725_get_integration_time(&g_sensor_itf, &time);
        if (rc) {
            goto err;
        }

        switch (time) {
            case TCS34725_INTEGRATIONTIME_2_4MS:
                console_printf("2.4\n");
                break;
            case TCS34725_INTEGRATIONTIME_24MS:
                console_printf("24\n");
                break;
            case TCS34725_INTEGRATIONTIME_50MS:
                console_printf("50\n");
                break;
            case TCS34725_INTEGRATIONTIME_101MS:
                console_printf("101\n");
                break;
            case TCS34725_INTEGRATIONTIME_154MS:
                console_printf("154\n");
                break;
            case TCS34725_INTEGRATIONTIME_700MS:
                console_printf("700\n");
                break;
            default:
                assert(0);
                break;
        }
    }

    /* Set the integration time */
    if (argc == 3) {
        val = parse_ll_bounds(argv[2], 0, 5, &rc);
        if (rc) {
            return tcs34725_shell_err_invalid_arg(argv[2]);
        }

        switch(val) {
            case 0:
                time = TCS34725_INTEGRATIONTIME_2_4MS;
                break;
            case 1:
                time = TCS34725_INTEGRATIONTIME_24MS;
                break;
            case 2:
                time = TCS34725_INTEGRATIONTIME_50MS;
                break;
            case 3:
                time = TCS34725_INTEGRATIONTIME_101MS;
                break;
            case 4:
                time = TCS34725_INTEGRATIONTIME_154MS;
                break;
            case 5:
                time = TCS34725_INTEGRATIONTIME_700MS;
                break;
            default:
                assert(0);
        }

        rc = tcs34725_set_integration_time(&g_sensor_itf, time);
        if (rc) {
            goto err;
        }
    }

    return 0;
err:
    return rc;
}


static int
tcs34725_shell_cmd_int(int argc, char **argv)
{
    int rc;
    int pin;
    uint16_t val;
    uint16_t lower;
    uint16_t upper;

    if (argc > 6) {
        return tcs34725_shell_err_too_many_args(argv[1]);
    }

    if (argc == 2) {
        rc = tcs34725_get_int_limits(&g_sensor_itf, &lower, &upper);
        if (rc) {
            return rc;
        }
        console_printf("Interrupt lower limit: %u upper limit: %u",
                       lower, upper);
        return 0;
    }

    /* Enable the interrupt */
    if (argc == 3 && strcmp(argv[2], "on") == 0) {
        return tcs34725_enable_interrupt(&g_sensor_itf, 1);
    }

    /* Disable the interrupt */
    if (argc == 3 && strcmp(argv[2], "off") == 0) {
        return tcs34725_enable_interrupt(&g_sensor_itf, 0);
    }

    /* Clear the interrupt on 'clr' */
    if (argc == 3 && strcmp(argv[2], "clr") == 0) {
        return tcs34725_clear_interrupt(&g_sensor_itf);
    }

    /* Configure the interrupt on 'set' */
    if (argc == 3 && strcmp(argv[2], "set") == 0) {
        /* Get lower threshold */
        val = parse_ll_bounds(argv[4], 0, UINT16_MAX, &rc);
        if (rc) {
            return tcs34725_shell_err_invalid_arg(argv[4]);
        }
        lower = val;
        /* Get upper threshold */
        val = parse_ll_bounds(argv[5], 0, UINT16_MAX, &rc);
        if (rc) {
            return tcs34725_shell_err_invalid_arg(argv[5]);
        }
        upper = val;
        /* Set the values */
        rc = tcs34725_set_int_limits(&g_sensor_itf, lower, upper);
        console_printf("Configured interrupt as:\n");
        console_printf("\tlower: %u\n", lower);
        console_printf("\tupper: %u\n", upper);
        return rc;
    }

    /* Setup INT pin on 'pin' */
    if (argc == 4 && strcmp(argv[2], "pin") == 0) {
        /* Get the pin number */
        val = parse_ll_bounds(argv[3], 0, 0xFF, &rc);
        if (rc) {
            return tcs34725_shell_err_invalid_arg(argv[3]);
        }
        pin = (int)val;
        /* INT is open drain, pullup is required */
        rc = hal_gpio_init_in(pin, HAL_GPIO_PULL_UP);
        assert(rc == 0);
        console_printf("Set pin \"%d\" to INPUT with pull up enabled\n", pin);
        return 0;
    }

    /* Unknown command */
    return tcs34725_shell_err_invalid_arg(argv[2]);
}


static int
tcs34725_shell_cmd_en(int argc, char **argv)
{
    char *endptr;
    long lval;
    int rc;
    uint8_t is_enabled;

    rc = 0;
    if (argc > 3) {
        return tcs34725_shell_err_too_many_args(argv[1]);
    }

    /* Display current enable state */
    if (argc == 2) {
        rc = tcs34725_get_enable(&g_sensor_itf, &is_enabled);
        if (rc) {
            console_printf("Cannot get enable state of the sensor\n");
            goto err;
        }
        console_printf("%u\n", is_enabled);
    }

    /* Update the enable state */
    if (argc == 3) {
        lval = strtol(argv[2], &endptr, 10); /* Base 10 */
        if (argv[2] != '\0' && *endptr == '\0' &&
            lval >= 0 && lval <= 1) {
                tcs34725_enable(&g_sensor_itf, lval);
        } else {
            return tcs34725_shell_err_invalid_arg(argv[2]);
        }
    }

    return 0;
err:
    return rc;
}

static int
tcs34725_shell_cmd_dump(int argc, char **argv)
{
  uint8_t val;

  if (argc > 3) {
      return tcs34725_shell_err_too_many_args(argv[1]);
  }

  /* Dump all the register values for debug purposes */
  val = 0;
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_ENABLE, &val));
  console_printf("0x%02X (ENABLE): 0x%02X\n", TCS34725_REG_ENABLE, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_ATIME, &val));
  console_printf("0x%02X (ATIME):  0x%02X\n", TCS34725_REG_ATIME, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_WTIME, &val));
  console_printf("0x%02X (WTIME):   0x%02X\n", TCS34725_REG_WTIME, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_AILTL, &val));
  console_printf("0x%02X (AILTL):   0x%02X\n", TCS34725_REG_AILTL, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_AILTH, &val));
  console_printf("0x%02X (AILTH):   0x%02X\n", TCS34725_REG_AILTH, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_AIHTL, &val));
  console_printf("0x%02X (AIHTL):   0x%02X\n", TCS34725_REG_AIHTL, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_AIHTH, &val));
  console_printf("0x%02X (AIHTH):   0x%02X\n", TCS34725_REG_AIHTH, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_PERS, &val));
  console_printf("0x%02X (PERS):   0x%02X\n", TCS34725_REG_PERS, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_CONFIG, &val));
  console_printf("0x%02X (CONFIG):   0x%02X\n", TCS34725_REG_CONFIG, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_CONTROL, &val));
  console_printf("0x%02X (CONTROL):   0x%02X\n", TCS34725_REG_CONTROL, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_ID, &val));
  console_printf("0x%02X (ID):    0x%02X\n", TCS34725_REG_ID, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_STATUS, &val));
  console_printf("0x%02X (STATUS):    0x%02X\n", TCS34725_REG_STATUS, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_CDATAL, &val));
  console_printf("0x%02X (CDATAL):    0x%02X\n", TCS34725_REG_CDATAL, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_CDATAH, &val));
  console_printf("0x%02X (CDATAH):    0x%02X\n", TCS34725_REG_CDATAH, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_RDATAL, &val));
  console_printf("0x%02X (RDATAL):    0x%02X\n", TCS34725_REG_RDATAL, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_RDATAH, &val));
  console_printf("0x%02X (RDATAH):    0x%02X\n", TCS34725_REG_RDATAH, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_GDATAL, &val));
  console_printf("0x%02X (GDATAL):    0x%02X\n", TCS34725_REG_GDATAL, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_GDATAH, &val));
  console_printf("0x%02X (GDATAH):    0x%02X\n", TCS34725_REG_GDATAH, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_BDATAL, &val));
  console_printf("0x%02X (BDATAL):    0x%02X\n", TCS34725_REG_BDATAL, val);
  assert(0 == tcs34725_read8(&g_sensor_itf, TCS34725_REG_BDATAH, &val));
  console_printf("0x%02X (BDATAH):    0x%02X\n", TCS34725_REG_BDATAH, val);

  return 0;
}

static int
tcs34725_shell_cmd(int argc, char **argv)
{
    if (argc == 1) {
        return tcs34725_shell_help();
    }

    /* Read command (get a new data sample) */
    if (argc > 1 && strcmp(argv[1], "r") == 0) {
        return tcs34725_shell_cmd_read(argc, argv);
    }

    /* Gain command */
    if (argc > 1 && strcmp(argv[1], "gain") == 0) {
        return tcs34725_shell_cmd_gain(argc, argv);
    }

    /* Integration time command */
    if (argc > 1 && strcmp(argv[1], "time") == 0) {
        return tcs34725_shell_cmd_time(argc, argv);
    }

    /* Enable */
    if (argc > 1 && strcmp(argv[1], "en") == 0) {
        return tcs34725_shell_cmd_en(argc, argv);
    }

    /* Interrupt */
    if (argc > 1 && strcmp(argv[1], "int") == 0) {
        return tcs34725_shell_cmd_int(argc, argv);
    }

    /* Debug */
    if (argc > 1 && strcmp(argv[1], "dumpreg") == 0) {
        return tcs34725_shell_cmd_dump(argc, argv);
    }

    return tcs34725_shell_err_unknown_arg(argv[1]);
}

int
tcs34725_shell_init(void)
{
    int rc;

    rc = shell_cmd_register(&tcs34725_shell_cmd_struct);
    SYSINIT_PANIC_ASSERT(rc == 0);

    return rc;
}

#endif