#pragma once
// PC stand-in for the Arduino core, just enough for robot/ to compile
// unchanged into the simulation DLL. Only on the sim's include path - the
// Teensy build never sees this file.
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <type_traits>

#ifndef PI
#define PI 3.1415926535897932384626433832795
#endif

// Arduino defines these as macros; templates behave the same for every use
// in robot/ without the double-evaluation surprises.
template <class T, class L, class H>
constexpr T constrain(T amt, L low, H high) {
  return amt < low ? (T)low : (amt > high ? (T)high : amt);
}
template <class A, class B>
constexpr typename std::common_type<A, B>::type min(A a, B b) { return a < b ? a : b; }
template <class A, class B>
constexpr typename std::common_type<A, B>::type max(A a, B b) { return a > b ? a : b; }

inline double radians(double deg) { return deg * (PI / 180.0); }
inline double degrees(double rad) { return rad * (180.0 / PI); }

// Pins and hardware PWM. analogWrite() pulses are recorded per pin, so the
// simulation sees servo pulses exactly as the PWM hardware would make them.
#define INPUT 0
#define OUTPUT 1
#define LOW 0
#define HIGH 1
void pinMode(uint8_t pin, uint8_t mode);
void digitalWrite(uint8_t pin, uint8_t value);
void analogWrite(uint8_t pin, int value);
uint32_t analogWriteResolution(uint32_t bits);   // returns the previous resolution, like Teensyduino
void analogWriteFrequency(uint8_t pin, float hz);

// Simulated clock, advanced by the simulation (see SimHardware.cpp).
uint32_t millis();
uint32_t micros();
void delay(uint32_t ms);
void delayMicroseconds(uint32_t us);

// USB serial: output is captured for Unity, input is fed from Unity.
class SimSerial {
public:
  void begin(unsigned long) {}
  int available();
  int read();
  size_t write(uint8_t c);
  size_t print(const char* s);
  size_t print(char c)          { return write((uint8_t)c); }
  size_t print(int v)           { return printf("%d", v); }
  size_t print(unsigned v)      { return printf("%u", v); }
  size_t print(long v)          { return printf("%ld", v); }
  size_t print(unsigned long v) { return printf("%lu", v); }
  size_t print(double v)        { return printf("%.2f", v); }
  template <class T> size_t println(T v) { size_t n = print(v); return n + print("\n"); }
  size_t println()              { return print("\n"); }
  size_t printf(const char* fmt, ...);
  operator bool() const { return true; }
};
extern SimSerial Serial;