🏗 Merge C++ into python codebase (#504)

## Description:

Move esphome-core codebase into esphome (and a bunch of other refactors). See https://github.com/esphome/feature-requests/issues/97

Yes this is a shit ton of work and no there's no way to automate it :( But it will be worth it 👍

Progress:
- Core support (file copy etc): 80%
- Base Abstractions (light, switch): ~50%
- Integrations: ~10%
- Working? Yes, (but only with ported components).

Other refactors:
- Moves all codegen related stuff into a single class: `esphome.codegen` (imported as `cg`)
- Rework coroutine syntax
- Move from `component/platform.py` to `domain/component.py` structure as with HA
- Move all defaults out of C++ and into config validation.
- Remove `make_...` helpers from Application class. Reason: Merge conflicts with every single new integration.
- Pointer Variables are stored globally instead of locally in setup(). Reason: stack size limit.

Future work:
- Rework const.py - Move all `CONF_...` into a conf class (usage `conf.UPDATE_INTERVAL` vs `CONF_UPDATE_INTERVAL`). Reason: Less convoluted import block
- Enable loading from `custom_components` folder.

**Related issue (if applicable):** https://github.com/esphome/feature-requests/issues/97

**Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>

## Checklist:
  - [ ] The code change is tested and works locally.
  - [ ] Tests have been added to verify that the new code works (under `tests/` folder).

If user exposed functionality or configuration variables are added/changed:
  - [ ] Documentation added/updated in [esphomedocs](https://github.com/OttoWinter/esphomedocs).

esphome/components/logger/logger.cpp

@@ -0,0 +1,149 @@
+#include "esphome/components/logger/logger.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+#include <esp_log.h>
+#endif
+#include <HardwareSerial.h>
+
+namespace esphome {
+namespace logger {
+
+static const char *TAG = "logger";
+
+int HOT Logger::log_vprintf_(int level, const char *tag, const char *format, va_list args) {  // NOLINT
+  if (level > this->level_for(tag))
+    return 0;
+
+  int ret = vsnprintf(this->tx_buffer_.data(), this->tx_buffer_.capacity(), format, args);
+  this->log_message_(level, tag, this->tx_buffer_.data(), ret);
+  return ret;
+}
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+int Logger::log_vprintf_(int level, const char *tag, const __FlashStringHelper *format, va_list args) {  // NOLINT
+  if (level > this->level_for(tag))
+    return 0;
+
+  // copy format string
+  const char *format_pgm_p = (PGM_P) format;
+  size_t len = 0;
+  char *write = this->tx_buffer_.data();
+  char ch = '.';
+  while (len < this->tx_buffer_.capacity() && ch != '\0') {
+    *write++ = ch = pgm_read_byte(format_pgm_p++);
+    len++;
+  }
+  if (len == this->tx_buffer_.capacity())
+    return -1;
+
+  // now apply vsnprintf
+  size_t offset = len + 1;
+  size_t remaining = this->tx_buffer_.capacity() - offset;
+  char *msg = this->tx_buffer_.data() + offset;
+  int ret = vsnprintf(msg, remaining, this->tx_buffer_.data(), args);
+  this->log_message_(level, tag, msg, ret);
+  return ret;
+}
+#endif
+
+int HOT Logger::level_for(const char *tag) {
+  // Uses std::vector<> for low memory footprint, though the vector
+  // could be sorted to minimize lookup times. This feature isn't used that
+  // much anyway so it doesn't matter too much.
+  for (auto &it : this->log_levels_) {
+    if (it.tag == tag) {
+      return it.level;
+    }
+  }
+  return this->global_log_level_;
+}
+void HOT Logger::log_message_(int level, const char *tag, char *msg, int ret) {
+  if (ret <= 0)
+    return;
+  // remove trailing newline
+  if (msg[ret - 1] == '\n') {
+    msg[ret - 1] = '\0';
+  }
+  if (this->baud_rate_ > 0)
+    this->hw_serial_->println(msg);
+  this->log_callback_.call(level, tag, msg);
+}
+
+Logger::Logger(uint32_t baud_rate, size_t tx_buffer_size, UARTSelection uart) : baud_rate_(baud_rate), uart_(uart) {
+  this->set_tx_buffer_size(tx_buffer_size);
+}
+
+void Logger::pre_setup() {
+  if (this->baud_rate_ > 0) {
+    switch (this->uart_) {
+      case UART_SELECTION_UART0:
+#ifdef ARDUINO_ARCH_ESP8266
+      case UART_SELECTION_UART0_SWAP:
+#endif
+        this->hw_serial_ = &Serial;
+        break;
+      case UART_SELECTION_UART1:
+        this->hw_serial_ = &Serial1;
+        break;
+#ifdef ARDUINO_ARCH_ESP32
+      case UART_SELECTION_UART2:
+        this->hw_serial_ = &Serial2;
+        break;
+#endif
+    }
+
+    this->hw_serial_->begin(this->baud_rate_);
+#ifdef ARDUINO_ARCH_ESP8266
+    if (this->uart_ == UART_SELECTION_UART0_SWAP) {
+      this->hw_serial_->swap();
+    }
+    this->hw_serial_->setDebugOutput(this->global_log_level_ >= ESPHOME_LOG_LEVEL_VERBOSE);
+#endif
+  }
+#ifdef ARDUINO_ARCH_ESP8266
+  else {
+    uart_set_debug(UART_NO);
+  }
+#endif
+
+  global_logger = this;
+#ifdef ARDUINO_ARCH_ESP32
+  esp_log_set_vprintf(esp_idf_log_vprintf_);
+  if (this->global_log_level_ >= ESPHOME_LOG_LEVEL_VERBOSE) {
+    esp_log_level_set("*", ESP_LOG_VERBOSE);
+  }
+#endif
+
+  ESP_LOGI(TAG, "Log initialized");
+}
+void Logger::set_baud_rate(uint32_t baud_rate) { this->baud_rate_ = baud_rate; }
+void Logger::set_global_log_level(int log_level) { this->global_log_level_ = log_level; }
+void Logger::set_log_level(const std::string &tag, int log_level) {
+  this->log_levels_.push_back(LogLevelOverride{tag, log_level});
+}
+void Logger::set_tx_buffer_size(size_t tx_buffer_size) { this->tx_buffer_.reserve(tx_buffer_size); }
+UARTSelection Logger::get_uart() const { return this->uart_; }
+void Logger::add_on_log_callback(std::function<void(int, const char *, const char *)> &&callback) {
+  this->log_callback_.add(std::move(callback));
+}
+float Logger::get_setup_priority() const { return setup_priority::HARDWARE - 1.0f; }
+const char *LOG_LEVELS[] = {"NONE", "ERROR", "WARN", "INFO", "DEBUG", "VERBOSE", "VERY_VERBOSE"};
+#ifdef ARDUINO_ARCH_ESP32
+const char *UART_SELECTIONS[] = {"UART0", "UART1", "UART2"};
+#endif
+#ifdef ARDUINO_ARCH_ESP8266
+const char *UART_SELECTIONS[] = {"UART0", "UART1", "UART0_SWAP"};
+#endif
+void Logger::dump_config() {
+  ESP_LOGCONFIG(TAG, "Logger:");
+  ESP_LOGCONFIG(TAG, "  Level: %s", LOG_LEVELS[this->global_log_level_]);
+  ESP_LOGCONFIG(TAG, "  Log Baud Rate: %u", this->baud_rate_);
+  ESP_LOGCONFIG(TAG, "  Hardware UART: %s", UART_SELECTIONS[this->uart_]);
+  for (auto &it : this->log_levels_) {
+    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.tag.c_str(), LOG_LEVELS[it.level]);
+  }
+}
+
+Logger *global_logger = nullptr;
+
+}  // namespace logger
+}  // namespace esphome