const char str[] = "abcdefgh æøå ÆØÅ";
const char nordic_chars[4] = {
  0xE6, // æ
  0xF8, // ø
  0xE5, // å
  0x00  // null
};

constexpr char ae = -26; //   xE6 \u00E6
constexpr char oe = -8;  //   xF8 \u00F8
constexpr char aa = -27; //   xE5 \u00E5

////////////////////////////////////////////////////

unsigned char splitSymbol(int16_t x) {
  uint8_t hi = x & 0xF0;
  uint8_t lo = x & 0x0F;

  Serial1.print("hi: 0x"); Serial1.println(hi, HEX);
  Serial1.print("lo: 0x"); Serial1.println(lo, HEX);
  return lo;
}


////////////////////////////////////////////////////

/*
void checkNorse(const char* str) {
  for (int i=0; i<strlen(str); i++) {

    int16_t val = str[i];
    if (!isAscii(val) || val > 127) {
      char bytes[3] = { '\0' };
      bytes[0] = (uint8_t)(val >> 8);    // High byte
      bytes[1] = (uint8_t)(val & 0xFF);  // Low byte  
      //bytes[0] = ((val) >> 8);
      //bytes[1] = ((val) & 0xFF);

      Serial1.print("byte 0: 0x"); Serial1.println(bytes[0], HEX);
      Serial1.print("byte 1: 0x"); Serial1.println(bytes[1], HEX);
    }
  }
}
////////////////////////////////////////////////////
*/

void checkChars() {
  Serial1.print("strlen: "); 
  Serial1.println(strlen(str));
  
  for (int i=0; i<strlen(str); i++) {
    Serial1.print(i);
    Serial1.print("\t0x");
    
    if (!isAscii(str[i]) || (int)str[i] > 127) {
      char temp[3] = { '\0' };
      for (int n=0; n<2; n++) {
        temp[n] = str[i];
        Serial1.print(str[i], HEX);
        i = (!n) ? i+1 : i; 
      }
      Serial1.print("\t"); 
      Serial1.print(temp);
    }
    else {
      Serial1.print(str[i], HEX);
      Serial1.print("\t");
      Serial1.print((char)str[i]); 
    }
  
    Serial1.println(); 
  }
}
////////////////////////////////////////////////////

void setString(char myArr[]) {
  Serial1.print("myArr: "); 
  Serial1.println(myArr);
  myArr[0] = 'c';
  strcat(myArr, "mand!");
}
////////////////////////////////////////////////////

void int2hex(int16_t value) {
  char bytes[3] = { '\0' };

  Serial1.println("int2hex():");

  // To split up in bytes:
  bytes[0] = (char)(value >> 8);    // High byte
  bytes[1] = (char)(value & 0xFF);  // Low byte  

  uint8_t hi = value & 0xF0;
  uint8_t lo = value & 0x0F;

  Serial1.print("byte 0: 0x"); Serial1.println(bytes[0], HEX);
  Serial1.print("byte 1: 0x"); Serial1.println(bytes[1], HEX);
  Serial1.println("\n------------------------------------------\n");
  /*
  // To reconstruct:
  int16_t reconstructed = (bytes[0] << 8) | bytes[1];
  Serial1.print("reconstructed: "); Serial1.println(reconstructed);
  Serial1.println((char)reconstructed);
  */
  //int val1 = (unsigned char)str3[0]; Serial1.println(val1);
}
////////////////////////////////////////////////////

void getBytes(const char* strn) {
  for (int i=0; i<strlen(strn); i++) {
    Serial1.print(i);
    Serial1.print("\t0x");
    
    if (!isAscii(strn[i]) || (int)strn[i] > 127) {
      char temp[3] = { '\0' };
      for (int n=0; n<2; n++) 
        temp[n] = strn[i], i = (!n) ? i+1 : i;

      uint8_t hi = temp[0];
      uint8_t lo = temp[1];

      Serial1.print(hi,HEX);
      Serial1.print("+");
      Serial1.print(lo,HEX);
      Serial1.print(" ");

      if (hi == 0xC3) {
        if (lo == 0xA6) Serial1.print("ae");
        if (lo == 0xB8) Serial1.print("oe");
        if (lo == 0xA5) Serial1.print("aa");
        if (lo == 0x86) Serial1.print("AE");
        if (lo == 0x98) Serial1.print("OE");
        if (lo == 0x85) Serial1.print("AA");
      }
    }
    else {
      Serial1.print(strn[i], HEX);
      Serial1.print("\t");
      Serial1.print((char)str[i]); 
    }
  
    Serial1.println(); 
  }
}
////////////////////////////////////////////////////

//#define lowByte(w) ((uint8_t) ((w) & 0xff))
//#define highByte(w) ((uint8_t) ((w) >> 8))

bool checkNorse(int16_t x) {
  uint8_t hi = ((x) & 0xF0);
  uint8_t lo = ((x) & 0x0F);


  Serial1.print("x:  "); Serial1.println(x);
  Serial1.print("hi: 0x"); Serial1.println(hi, HEX);
  Serial1.print("lo: 0x"); Serial1.println(lo, HEX);
  Serial1.println();
  /*
  if ( (lo != 0x05 && lo != 0x06 && lo != 0x08) || 
       (hi != 0x80 && hi != 0x90 && hi != 0xA0  &&  hi != 0xB0))
    return false;
    
  if (lo == 0x05)
    display.print((hi == 0xA0 || hi == 0xB0) ? "aa" : "AA");
  else
  if (lo == 0x06)
    display.print((hi == 0xA0 || hi == 0xB0) ? "ae" : "AE");
  else
  if (lo == 0x08)
    display.print((hi == 0xA0 || hi == 0xB0) ? "oe" : "OE");
  */
  return true;
}
////////////////////////////////////////////////////


char buff[64] =  { '\0' };

void storeBytes(const char* strn) {
  uint8_t hi, lo, c = 0;
  char temp[3] = { '\0' };
  buff[0] = '\0';

  for (int i=0; i<strlen(strn); i++) {
    temp[0] = temp[1] = temp[2] = '\0';
    
    if (!isAscii(strn[i]) || (int)strn[i] > 127) {
      for (int n=0; n<2; n++) 
        temp[n] = strn[i],
        i = (!n) ? i+1 : i;

      hi = temp[0];
      lo = temp[1];

      if (hi == 0xC3) {
        if      (lo == 0xA6) strcpy(temp, "ae"); 
        else if (lo == 0xB8) strcpy(temp, "oe");
        else if (lo == 0xA5) strcpy(temp, "aa");
        else if (lo == 0x86) strcpy(temp, "AE");
        else if (lo == 0x98) strcpy(temp, "OE");
        else if (lo == 0x85) strcpy(temp, "AA");
      }
      strcat(buff, temp);
    }
    else {
      temp[0] = (char)str[i],
      strcat(buff, temp);
    }
  }
  if (strlen(buff))
    Serial1.println("buffer:"),
    Serial1.println(buff);
}

////////////////////////////////////////////////////

void setup() {
  
  char myStr[16] = {'\0'};
  char hx[3] = {'\0'};
  
  Serial1.begin(115200);
  Serial1.println("");

// ---------------------------------------------------------------

  //checkChars(); Serial1.println();

  const char str2[] = "abc æøå ÆØÅ";
  storeBytes(str2);
  //getBytes(str2);
  //for (int i=0; i<strlen(str2); i++) checkNorse(str2[i]);
  

  // ---------------------------------------------------------------
  /*
  char myChar = 'Æ';
  splitSymbol((unsigned char)myChar);

  // ---------------------------------------------------------------

  uint8_t myByte = 0xA5;
  hx[0] = (unsigned char)myByte;
  Serial1.print("myByte: "); Serial1.println(hx);  
  int2hex(myByte);
  int2hex((unsigned char)'ø');
  */
  //----------------------------------------------------------------

  /*
  strcpy(myStr, "hej ");
  setString(myStr);
  Serial1.print("\nmyStr[]: "); 
  Serial1.println(myStr);
  Serial1.println("\n------------------------------------------\n");

  checkChars();
  Serial1.println("\n------------------------------------------\n");
  Serial1.print("HEX: "); Serial1.println("\xE6");
  Serial1.print("UC:  "); Serial1.println("\u00E6");

  strcpy(hx, "\u00E6");
  Serial1.println(hx);
  Serial1.print("  0: "); Serial1.println(hx[0], HEX);
  Serial1.print("  1: "); Serial1.println(hx[1], HEX);

  myByte = 0xA5;
  hx[1] = (unsigned char)myByte;
  Serial1.print("myByte: "); Serial1.println(hx);
  Serial1.print("  0: "); Serial1.println(hx[0], HEX);
  Serial1.print("  1: "); Serial1.println(hx[1], HEX);
  Serial1.println("\n------------------------------------------\n");  
  */    
  /*
  unsigned char uc = ae;
  hx[0] = (char)uc;
  hx[1] = '\0';
  //Serial1.println(hx);
  */
  /*
  //int16_t value = 253; // Example >255 value
  int16_t value = 'Æ';
  char bytes[3];

  bytes[0] = (char)(value >> 8);    // High byte
  bytes[1] = (char)(value & 0xFF);  // Low byte  
  bytes[2] = '\0';

  // To reconstruct:
  int16_t reconstructed = (bytes[0] << 8) | bytes[1];
  Serial1.print("reconstructed: "); Serial1.println(reconstructed);
  Serial1.println((char)reconstructed);
  */

  //decodeStr("tittebøh mæh!");
  //checkChars();

}

void loop() {
  delay(1);
}