#include "keyus.h"

// kb_key_return 4-byte structure
typedef struct {
      byte status;
      byte lights;
      byte scancode;
      byte character;
} kb_key;

byte kb_array[16];
volatile static byte kb_newdata;

/*********DEBUG**************/
void kb_print_binary(int x, int y, byte what)
{
      char arr[9]; int i;
      for (i = 7; i>=0; i--, what/=2)
            arr[i] = (what%2) + '0';
            
      arr[8] = 0;
      
      puts_pos(x,y,arr);

}
/*********DEBUG**************/

void kb_set_key(byte scancode, byte val)
{
      byte pos = scancode/8;
      byte offset = scancode%8;
      
      if (val) {
            kb_array[pos] |= 1<<offset;
            kb_newdata = scancode;
            }
      else kb_array[pos] &= 0xFF - (1<<offset);
}

byte kb_get_key(byte scancode)
{
      byte pos = scancode/8;
      byte offset = scancode%8;
      return (kb_array[pos]&(1<<offset));
}


void kb_handler(regs *r) {
      byte scancode = inportb(0x60);

      switch (scancode) {
            case 0x00:                                      // Error 0x00
            case 0xFC:                                      // Diagnostics failed (MF kb)
            case 0xFD:                                      // Diagnostics failed (AT kb)
            case 0xFF: kb_waitin(); outportb(0x60, 0xF4);   // Error 0xFF
                        break;
            case 0xAA:                                      // BAT test successful.
            case 0xFA:                                      // ACKnowledge
            case 0xFE:                                      // Last command invalid or parity error
            case 0xEE: break;                              // Echo response
        // Gray or break
            case 0xE0: kb_prefix |= 1; break;
            case 0xE1: kb_prefix |= 4; break;
            case 0xF0: kb_prefix |= 2; break;

        // Alt, ctrl...
            case 0x11: if ((kb_prefix&1) == 0) {              // Left alt
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<2;
                           else kb_modifier_status &= 0xFF - (1<<2);
                        }
                        else {                              // Right alt
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<3;
                           else kb_modifier_status &= 0xFF - (1<<3);
                        }
                        kb_prefix = 0; break;
                        
            case 0x12: if ((kb_prefix&1) == 0) {              // Left shift
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<0;
                           else kb_modifier_status &= 0xFF - (1<<0);
                        }
                        else {                              // Fake shift
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<6;
                           else kb_modifier_status &= 0xFF - (1<<6);
                        }
                        kb_prefix = 0; break;
                        
            //TO ADD BELOW: pause/break byte1
            case 0x14: if (kb_prefix&4) {
                              if ((kb_prefix&2) == 0) kb_set_key (0, 1);
                              else kb_set_key (0, 0);
                              kb_prefix |= 8; break;
                              }
            
                        else if ((kb_prefix&1) == 0) {              // Left ctrl
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<4;
                           else kb_modifier_status &= 0xFF - (1<<4);
                        }
                        else {                              // Right ctrl
                           if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<5;
                           else kb_modifier_status &= 0xFF - (1<<5);
                        }
                        kb_prefix = 0; break;
                        
            case 0x59:                                      // Right shift
                        if ((kb_prefix&2) == 0) kb_modifier_status |= 1<<1;
                        else kb_modifier_status &= 0xFF - (1<<1);

                        kb_prefix = 0; break;
                        
        // LEDs
            case 0x58: if ((kb_prefix&2) == 0) {
                  kb_lights_status ^= 4; kb_set_LEDs(kb_lights_status);
                  } kb_prefix = 0; break; // Caps
                  
            //TO ADD BELOW: pause/break byte2
            case 0x77:
                  if ((kb_prefix&4) && (kb_prefix&8)) kb_prefix=0;
                  else if ((kb_prefix&2) == 0) {
                  kb_lights_status ^= 2; kb_set_LEDs(kb_lights_status); 
                  } kb_prefix = 0; break; // Num
            case 0x7E: if ((kb_prefix&2) == 0) {
                  kb_lights_status ^= 1; kb_set_LEDs(kb_lights_status); 
                  } kb_prefix = 0; break; // Scroll
                        
            case 0x83: scancode = 0x02; // Put F7 under the 0x80 (128bit) barrier
                        
            default: 
                  // Remap gray keys
                  if (kb_prefix&1) switch (scancode) {
                        case 0x7C: scancode=0x08; break;    // PrintScreen
                        case 0x4A: scancode=0x6A; break;    // Numpad /
                        case 0x5A: scancode=0x59; break;    // Numpad Enter
                        case 0x69: scancode=0x5E; break;    // End
                        case 0x6B: scancode=0x5F; break;    // Left
                        case 0x6C: scancode=0x60; break;    // Home
                        case 0x70: scancode=0x61; break;    // Insert
                        case 0x71: scancode=0x62; break;    // Delete
                        case 0x72: scancode=0x63; break;    // Down
                        case 0x74: scancode=0x64; break;    // Right
                        case 0x75: scancode=0x65; break;    // Up
                        case 0x7A: scancode=0x67; break;    // PageDown
                        case 0x7D: scancode=0x68; break;    // PageUp
                        }
                  if ((kb_prefix&2) == 0) kb_set_key(scancode, 1);
                  else kb_set_key(scancode, 0);
                  
                  kb_prefix = 0; break;
      }
      
      // Alt+ctrl+del = reset
      if (scancode==0x62) {
            int ok=0;
            if ((kb_modifier_status&4) || (kb_modifier_status&8)) ok++;
            if ((kb_modifier_status&16) || (kb_modifier_status&32)) ok++;
            if (ok==2) reboot();
            }
      
      outportb(0x20, 0x20);
}



kb_key kb_getkey()
{
      kb_key ret;
      
      kb_newdata = 0xFF;
      while (kb_newdata==0xFF);              // wait for keypress
      
      ret.scancode = kb_newdata;          // Send scancode for non-chars
      ret.status = kb_modifier_status;    // Shift, ctrl... state
      ret.lights = kb_lights_status;      // Num, caps.... state
      
      if ((ret.status & 1) || (ret.status & 2)) // Shift is on
            ret.character = kbdus_map_shift[ret.scancode];
      else ret.character = kbdus_map[ret.scancode]; // Shift is off
      
      return ret;                         // And send it.
}