#ifndef __debug_h_

#define __debug_h_

#include <avr/pgmspace.h>

#include <stdio.h>

#include <stdlib.h>

#include <config.h>

#ifdef UART_BUFFERED_OUTPUT

#   include "uart_buffered_proto.h"

#else

#   include "uart.h"

#endif

#include "sensors.h"

#if(DEBUG)

    /**

     * printf-style macro for debugging.  Operates identically to printf.

     * The format string will be stored in program memory to minimize RAM

     * usage.

     */

#   define debugf(format, ...) { \

        debug_printf(PSTR(format), ## __VA_ARGS__); \

    }

/** Constant string "OK" that is used in various debug output */

extern const PROGMEM char debug_str_ok[];

/** Constant string "FAIL" that is used in various debug output */

extern const PROGMEM char debug_str_fail[];

/** Constant string "true" that is used in JSON output */

extern const PROGMEM char debug_str_true[];

/** Constant string "false" that is used in JSON output */

extern const PROGMEM char debug_str_false[];

/** Global state that keeps track of when to insert commas in the JSON output */

extern uint8_t debug_json_comma_status;

/**

 * Prints the status of something, intended to be used in sensor

 * initialization.  Success is assumed to be indicated by 0 and anything else

 * is considered an error.  The status code is also printed out.

 * @param name a string literal naming the sensor

 * @param status the status code to report

 */

#   define debug_sensor_status(name, status) \

        debugf("  % 10S:  %S (%d)\n", PSTR(name), (status) == 0 ? debug_str_ok : \

            debug_str_fail, status)

#   if(JSON_OUTPUT)

        /**

         * Inserts a comma into the JSON output if one is necessary.

         */

#       define debug_json_comma() { if(!debug_json_comma_status) { \

            debug_json_comma_status = 1; \

            } else { debugf(",\n") } }

        /**

         * Begins printing JSON output for senor data.

         */

#       define debug_json_start(name) { debug_json_comma_status = 0; \

            debugf("'%S': {\n", PSTR(name)) }

        /* json output for sensor values */

        /**

         * Outputs an integer sensor value as JSON.

         * @param name a string literal identifying the sensor.

         * @param value the value to print

         */

#       define debug_json_sensor_int(name, value) { debug_json_comma(); \

            debugf("    '%S': %d", PSTR(name), value) }

        /**

         * Outputs an integer sensor value as JSON.

         * @param name a string literal identifying the sensor.

         * @param value the value to print

         */

#       define debug_json_sensor_uint(name, value) { debug_json_comma(); \

            debugf("    '%S': %u", PSTR(name), value) }

#       define debug_json_sensor_dec(fmt, name, value, frac) { \

            debug_json_comma(); \

            ldiv_t res = ldiv(value, frac); \

            char neg = ' '; \

            if(value < 0) { \

                res.quot *= -1; \

                res.rem *= -1; \

                neg = '-'; \

            } \

            debugf(fmt, name, neg, res.quot, res.rem);\

        }

        /**

         * Outputs a fixed point decimal sensor value as JSON, with 1 digit 

         * following the decimal point.

         * @param name a string literal identifying the sensor.

         * @param value the value to print

         */

#       define debug_json_sensor_dec1(name, value) \

            debug_json_sensor_dec("    '%S': %c%ld.%01ld", PSTR(name), \

                value, 10L)

        /**

         * Outputs a fixed point decimal sensor value as JSON, with 2 digits

         * following the decimal point.

         * @param name a string literal identifying the sensor.

         * @param value the value to print

         */

#       define debug_json_sensor_dec2(name, value) \

            debug_json_sensor_dec("    '%S': %c%ld.%02ld", PSTR(name), \

                value, 100L)

        /**

         * Outputs a fixed point decimal sensor value as JSON, with 3 digits 

         * following the decimal point.

         * @param name a string literal identifying the sensor.

         * @param value the value to print

         */

#       define debug_json_sensor_dec3(name, value) \

            debug_json_sensor_dec("    '%S': %c%ld.%03ld", PSTR(name), \

                value, 1000L)

        /**

         * Outputs a fixed point decimal sensor value as JSON, with 4 digits 

         * following the decimal point.

         * @param name a string literal identifying the sensor.

         * @param value the value to print

         */

#       define debug_json_sensor_dec4(name, value) \

            debug_json_sensor_dec("    '%S': %c%ld.%04ld", PSTR(name), \

                value, 10000L)

        /**

         * Outputs a boolean sensor value as JSON.

         * @param name a string literal identifying the sensor.

         * @param value the value to print

         */

#       define debug_json_sensor_bool(name, value) { debug_json_comma(); \

            debugf("    '%S': %S", PSTR(name), value ? debug_str_true : \

            debug_str_false) }

#       define debug_json_sensor_pstr(name, value) { debug_json_comma(); \

            debugf("    '%S': %S", PSTR(name), value) }

        /**

         * Outputs an integer as a 16-bit hex value as JSON.

         * @param name a string literal identifying the number

         * @param value the value to print

         */

#       define debug_json_addr(name, value) { debug_json_comma(); \

            debugf("    '%S': \"0x%04X\"", PSTR(name), value) }

        /* variant where sensor name is not a string constant */

        /**

         * Outputs an integer sensor value as JSON.

         * @param name a pointer to a string in program memory identifying the

         * sensor.

         * @param value the value to print

         */

#       define debug_json_sensorn_int(name, value) { debug_json_comma(); \

            debugf("    '%S': %d", name, value) }

        /**

         * Outputs a fixed-point decimal sensor value as JSON, with 1 digit

         * following the decimal point.

         * @param name a pointer to a string in program memory identifying the

         * sensor.

         * @param value the value to print

         */

#       define debug_json_sensorn_uint(name, value) { debug_json_comma(); \

            debugf("    '%S': %u", name, value) }

        /**

         * Outputs a fixed-point decimal sensor value as JSON, with 1 digit

         * following the decimal point.

         * @param name a pointer to a string in program memory identifying the

         * sensor.

         * @param value the value to print

         */

#       define debug_json_sensorn_dec1(name, value) \

            debug_json_sensor_dec("    '%S': %c%ld.%01ld", name, \

                value, 10L)

        /**

         * Outputs a fixed-point decimal sensor value as JSON, with 2 digits

         * following the decimal point.

         * @param name a pointer to a string in program memory identifying the

         * sensor.

         * @param value the value to print

         */

#       define debug_json_sensorn_dec2(name, value) \

            debug_json_sensor_dec("    '%S': %c%ld.%02ld", name, \

                value, 100L)

        /**

         * Outputs a fixed-point decimal sensor value as JSON, with 3 digits

         * following the decimal point.

         * @param name a pointer to a string in program memory identifying the

         * sensor.

         * @param value the value to print

         */

#       define debug_json_sensorn_dec3(name, value) \

            debug_json_sensor_dec("    '%S': %c%ld.%03ld", name, \

                value, 1000L)

        /**

         * Outputs a fixed-point decimal sensor value as JSON, with 4 digits

         * following the decimal point.

         * @param name a pointer to a string in program memory identifying the

         * sensor.

         * @param value the value to print

         */

#       define debug_json_sensorn_dec4(name, value) \

            debug_json_sensor_dec("    '%S': %c%ld.%04ld", name, \

                value, 10000L)

        /**

         * Closes the JSON output of sensor data.

         */

#       define debug_json_end() debugf("\n}\n")

#   else

        #define debug_json_start()

        #define debug_json_sensor_int(name, value)

        #define debug_json_sensor_dec2(name, value, prec)

        #define debug_json_sensor_dec1(name, value, prec)

        #define debug_json_end()

#   endif

#else

#define debugf(format, ...)

#define debug(str)

#endif

/**

 * Internal function for sending debug output; this should not be called

 * directly (using the macros instead will omit the strings from the 

 * executable if debugging is turned off, while calling this directly

 * won't)

 */

void debug_printf(const char *fmt, ...);

/**

 * Initializes the debug system with the given serial port.

 * @param uart the UART to use for debugging output, if debugging is enabled.

 */

void debug_setup(uart_t *uart);

#endif // __debug_h_