// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'dart:math';

import 'terminfo.dart';

typedef List<String> CommandCompleter(List<String> commandParts);

class Commando {
  // Ctrl keys
  static const runeCtrlA   = 0x01;
  static const runeCtrlB   = 0x02;
  static const runeCtrlD   = 0x04;
  static const runeCtrlE   = 0x05;
  static const runeCtrlF   = 0x06;
  static const runeTAB     = 0x09;
  static const runeNewline = 0x0a;
  static const runeCtrlK   = 0x0b;
  static const runeCtrlL   = 0x0c;
  static const runeCtrlN   = 0x0e;
  static const runeCtrlP   = 0x10;
  static const runeCtrlU   = 0x15;
  static const runeCtrlY   = 0x19;
  static const runeESC     = 0x1b;
  static const runeSpace   = 0x20;
  static const runeDEL     = 0x7F;

  StreamController<String> _commandController;

  Stream get commands => _commandController.stream;

  Commando({consoleIn,
            consoleOut,
            this.prompt : '> ',
          this.completer : null}) {
    _stdin = (consoleIn != null ? consoleIn : stdin);
    _stdout = (consoleOut != null ? consoleOut : stdout);
    _commandController = new StreamController<String>(
        onCancel: _onCancel);
    _stdin.echoMode = false;
    _stdin.lineMode = false;
    _screenWidth = _term.cols - 1;
    _writePrompt();
    // TODO(turnidge): Handle errors in _stdin here.
    _stdinSubscription =
        _stdin.transform(UTF8.decoder).listen(_handleText, onDone:_done);
  }

  Future _onCancel() {
    _stdin.echoMode = true;
    _stdin.lineMode = true;
    var future = _stdinSubscription.cancel();
    if (future != null) {
      return future;
    } else {
      return new Future.value();
    }
  }

  // Before terminating, call close() to restore terminal settings.
  void _done() {
    _onCancel().then((_) {
        _commandController.close();
      });
  }
  
  void _handleText(String text) {
    try {
      if (!_promptShown) {
        _bufferedInput.write(text);
        return;
      }

      var runes = text.runes.toList();
      var pos = 0;
      while (pos < runes.length) {
        if (!_promptShown) {
          // A command was processed which hid the prompt.  Buffer
          // the rest of the input.
          //
          // TODO(turnidge): Here and elsewhere in the file I pass
          // runes to String.fromCharCodes.  Does this work?
          _bufferedInput.write(
              new String.fromCharCodes(runes.skip(pos)));
          return;
        }

        var rune = runes[pos];

        // Count consecutive tabs because double-tab is meaningful.
        if (rune == runeTAB) {
          _tabCount++;
        } else {
          _tabCount = 0;
        }

        if (_isControlRune(rune)) {
          pos += _handleControlSequence(runes, pos);
        } else {
          pos += _handleRegularSequence(runes, pos);
        }
      }
    } catch(e, trace) {
      _commandController.addError(e, trace);
    }
  }

  int _handleControlSequence(List<int> runes, int pos) {
    var runesConsumed = 1;  // Most common result.
    var char = runes[pos];
    switch (char) {
      case runeCtrlA:
        _home();
        break;
           
      case runeCtrlB:
        _leftArrow();
        break;

      case runeCtrlD:
        if (_currentLine.length == 0) {
          // ^D on an empty line means quit.
          _stdout.writeln("^D");
          _done();
        } else {
          _delete();
        }
        break;
           
      case runeCtrlE:
        _end();
        break;
           
      case runeCtrlF:
        _rightArrow();
        break;

      case runeTAB:
        if (_complete(_tabCount > 1)) {
          _tabCount = 0;
        }
        break;
      
      case runeNewline:
        _newline();
        break;
      
      case runeCtrlK:
        _kill();
        break;
           
      case runeCtrlL:
        _clearScreen();
        break;
           
      case runeCtrlN:
        _historyNext();
        break;

      case runeCtrlP:
        _historyPrevious();
        break;

      case runeCtrlU:
        _clearLine();
        break;
           
      case runeCtrlY:
        _yank();
        break;
           
      case runeESC:
        // Check to see if this is an arrow key.
        if (pos + 2 < runes.length &&  // must be a 3 char sequence.
            runes[pos + 1] == 0x5b) {  // second char must be '['.
          switch (runes[pos + 2]) {
            case 0x41:  // ^[[A = up arrow
              _historyPrevious();
              runesConsumed = 3;
              break;

            case 0x42:  // ^[[B = down arrow
              _historyNext();
              runesConsumed = 3;
              break;

            case 0x43:  // ^[[C = right arrow
              _rightArrow();
              runesConsumed = 3;
              break;
        
            case 0x44:  // ^[[D = left arrow
              _leftArrow();
              runesConsumed = 3;
              break;

            default:
              // Ignore the escape character.
              break;
          }
        }
        break;

      case runeDEL:
        _backspace();
        break;

      default:
        // Ignore the escape character.
        break;
    }
    return runesConsumed;
  }

  int _handleRegularSequence(List<int> runes, int pos) {
    var len = pos + 1;
    while (len < runes.length && !_isControlRune(runes[len])) {
      len++;
    }
    _addChars(runes.getRange(pos, len));
    return len;
  }

  bool _isControlRune(int char) {
    return (char >= 0x00 && char < 0x20) || (char == 0x7f);
  }

  void _writePromptAndLine() {
    _writePrompt();
    var pos = _writeRange(_currentLine, 0, _currentLine.length);
    _cursorPos = _move(pos, _cursorPos);
  }

  void _writePrompt() {
    _stdout.write(prompt);
  }

  void _addChars(Iterable<int> chars) {
    var newLine = [];
    newLine..addAll(_currentLine.take(_cursorPos))
           ..addAll(chars)
           ..addAll(_currentLine.skip(_cursorPos));
    _update(newLine, (_cursorPos + chars.length));
  }

  void _backspace() {
    if (_cursorPos == 0) {
      return;
    }

    var newLine = [];
    newLine..addAll(_currentLine.take(_cursorPos - 1))
           ..addAll(_currentLine.skip(_cursorPos));
    _update(newLine, (_cursorPos - 1));
  }

  void _delete() {
    if (_cursorPos == _currentLine.length) {
      return;
    }

    var newLine = [];
    newLine..addAll(_currentLine.take(_cursorPos))
           ..addAll(_currentLine.skip(_cursorPos + 1));
    _update(newLine, _cursorPos);
  }

  void _home() {
    _updatePos(0);
  }

  void _end() {
    _updatePos(_currentLine.length);
  }

  void _clearScreen() {
    _stdout.write(_term.clear);
    _term.resize();
    _screenWidth = _term.cols - 1;
    _writePromptAndLine();
  }

  void _kill() {
    var newLine = [];
    newLine.addAll(_currentLine.take(_cursorPos));
    _killBuffer = _currentLine.skip(_cursorPos).toList();
    _update(newLine, _cursorPos);
  }

  void _clearLine() {
    _update([], 0);
  }

  void _yank() {
    var newLine = [];
    newLine..addAll(_currentLine.take(_cursorPos))
           ..addAll(_killBuffer)
           ..addAll(_currentLine.skip(_cursorPos));
    _update(newLine, (_cursorPos + _killBuffer.length));
  }

  static String _trimLeadingSpaces(String line) {
    bool _isSpace(int rune) {
      return rune == runeSpace;
    }
    return new String.fromCharCodes(line.runes.skipWhile(_isSpace));
  }

  static String _sharedPrefix(String one, String two) {
    var len = min(one.length, two.length);
    var runesOne = one.runes.toList();
    var runesTwo = two.runes.toList();
    var pos;
    for (pos = 0; pos < len; pos++) {
      if (runesOne[pos] != runesTwo[pos]) {
        break;
      }
    }
    var shared =  new String.fromCharCodes(runesOne.take(pos));
    return shared;
  }

  bool _complete(bool showCompletions) {
    if (completer == null) {
      return false;
    }

    var linePrefix = _currentLine.take(_cursorPos).toList();
    List<String> commandParts =
        _trimLeadingSpaces(new String.fromCharCodes(linePrefix)).split(' ');
    List<String> completionList = completer(commandParts);
    var completion = '';

    if (completionList.length == 0) {
      // The current line admits no possible completion.
      return false;

    } else if (completionList.length == 1) {
      // There is a single, non-ambiguous completion for the current line.
      completion = completionList[0];

      // If we are at the end of the line, add a space to signal that
      // the completion is unambiguous.
      if (_currentLine.length == _cursorPos) {
        completion = completion + ' ';
      }
    } else {
      // There are ambiguous completions. Find the longest common
      // shared prefix of all of the completions.
      completion = completionList.fold(completionList[0], _sharedPrefix);
    }

    var lastWord = commandParts.last;
    if (completion == lastWord) {
      // The completion does not add anything.
      if (showCompletions) {
        // User hit double-TAB.  Show them all possible completions.
        _move(_cursorPos, _currentLine.length);
        _stdout.writeln();
        _stdout.writeln(completionList);
        _writePromptAndLine();
      }
      return false;
    } else {
      // Apply the current completion.
      var completionRunes = completion.runes.toList();

      var newLine = [];
      newLine..addAll(linePrefix)
             ..addAll(completionRunes.skip(lastWord.length))
             ..addAll(_currentLine.skip(_cursorPos));
      _update(newLine, _cursorPos + completionRunes.length - lastWord.length);
      return true;
    }
  }

  void _newline() {
    _addLineToHistory(_currentLine);
    _linePos = _lines.length;

    _end();
    _stdout.writeln();

    // Call the user's command handler.
    _commandController.add(new String.fromCharCodes(_currentLine));
    
    _currentLine = [];
    _cursorPos = 0;
    if (_promptShown) {
      _writePrompt();
    }
  }

  void _leftArrow() {
    _updatePos(_cursorPos - 1);
  }

  void _rightArrow() {
    _updatePos(_cursorPos + 1);
  }

  void _addLineToHistory(List<int> line) {
    if (_tempLineAdded) {
      _lines.removeLast();
      _tempLineAdded = false;
    }
    if (line.length > 0) {
      _lines.add(line);
    }
  }

  void _addTempLineToHistory(List<int> line) {
    _lines.add(line);
    _tempLineAdded = true;
  }

  void _replaceHistory(List<int> line, int linePos) {
    _lines[linePos] = line;
  }

  void _historyPrevious() {
    if (_linePos == 0) {
      return;
    }

    if (_linePos == _lines.length) {
      // The current in-progress line gets temporarily stored in history.
      _addTempLineToHistory(_currentLine);
    } else {
      // Any edits get committed to history.
      _replaceHistory(_currentLine, _linePos);
    }

    _linePos -= 1;
    var line = _lines[_linePos];
    _update(line, line.length);
  }

  void _historyNext() {
    // For the very first command, _linePos (0) will exceed
    // (_lines.length - 1) (-1) so we use a ">=" here instead of an "==".
    if (_linePos >= (_lines.length - 1)) {
      return;
    }

    // Any edits get committed to history.
    _replaceHistory(_currentLine, _linePos);

    _linePos += 1;
    var line = _lines[_linePos];
    _update(line, line.length);
  }

  void _updatePos(int newCursorPos) {
    if (newCursorPos < 0) {
      return;
    }
    if (newCursorPos > _currentLine.length) {
      return;
    }

    _cursorPos = _move(_cursorPos, newCursorPos);
  }

  void _update(List<int> newLine, int newCursorPos) {
    var pos = _cursorPos;
    var diffPos;
    var sharedLen = min(_currentLine.length, newLine.length);

    // Find first difference.
    for (diffPos = 0; diffPos < sharedLen; diffPos++) {
      if (_currentLine[diffPos] != newLine[diffPos]) {
        break;
      }
    }

    // Move the cursor to where the difference begins.
    pos = _move(pos, diffPos);

    // Write the new text.
    pos = _writeRange(newLine, pos, newLine.length);

    // Clear any extra characters at the end.
    pos = _clearRange(pos, _currentLine.length);

    // Move the cursor back to the input point.
    _cursorPos = _move(pos, newCursorPos);
    _currentLine = newLine;    
  }
  
  void hide() {
    if (!_promptShown) {
      return;
    }
    _promptShown = false;
    // We need to erase everything, including the prompt.
    var curLine = _getLine(_cursorPos);
    var lastLine = _getLine(_currentLine.length);

    // Go to last line.
    if (curLine < lastLine) {
      for (var i = 0; i < (lastLine - curLine); i++) {
        // This moves us to column 0.
        _stdout.write(_term.cursorDown);
      }
      curLine = lastLine;
    } else {
      // Move to column 0.
      _stdout.write('\r');
    }

    // Work our way up, clearing lines.
    while (true) {
      _stdout.write(_term.clrEOL);
      if (curLine > 0) {
        _stdout.write(_term.cursorUp);
      } else {
        break;
      }
    }
  }

  void show() {
    if (_promptShown) {
      return;
    }
    _promptShown = true;
    _writePromptAndLine();

    // If input was buffered while the prompt was hidden, process it
    // now.
    if (!_bufferedInput.isEmpty) {
      var input = _bufferedInput.toString();
      _bufferedInput.clear();
      _handleText(input);
    }
  }

  int _writeRange(List<int> text, int pos, int writeToPos) {
    if (pos >= writeToPos) {
      return pos;
    }
    while (pos < writeToPos) {
      var margin = _nextMargin(pos);
      var limit = min(writeToPos, margin);
      _stdout.write(new String.fromCharCodes(text.getRange(pos, limit)));
      pos = limit;
      if (pos == margin) {
        _stdout.write('\n');
      }
    }
    return pos;
  }

  int _clearRange(int pos, int clearToPos) {
    if (pos >= clearToPos) {
      return pos;
    }
    while (true) {
      var limit = _nextMargin(pos);
      _stdout.write(_term.clrEOL);
      if (limit >= clearToPos) {
        return pos;
      }
      _stdout.write('\n');
      pos = limit;
    }
  }

  int _move(int pos, int newPos) {
    if (pos == newPos) {
      return pos;
    }

    var curCol = _getCol(pos);
    var curLine = _getLine(pos);
    var newCol = _getCol(newPos);
    var newLine = _getLine(newPos);

    if (curLine > newLine) {
      for (var i = 0; i < (curLine - newLine); i++) {
        _stdout.write(_term.cursorUp);
      }
    }
    if (curLine < newLine) {
      for (var i = 0; i < (newLine - curLine); i++) {
        _stdout.write(_term.cursorDown);
      }

      // Moving down resets column to zero, oddly.
      curCol = 0;
    }
    if (curCol > newCol) {
      for (var i = 0; i < (curCol - newCol); i++) {
        _stdout.write(_term.cursorBack);
      }
    }
    if (curCol < newCol) {
      for (var i = 0; i < (newCol - curCol); i++) {
        _stdout.write(_term.cursorForward);
      }
    }

    return newPos;
  }
        
  int _nextMargin(int pos) {
    var truePos = pos + prompt.length;
    return ((truePos ~/ _screenWidth) + 1) * _screenWidth - prompt.length;
  }

  int _getLine(int pos) {
    var truePos = pos + prompt.length;
    return truePos ~/ _screenWidth;
  }

  int _getCol(int pos) {
    var truePos = pos + prompt.length;
    return truePos % _screenWidth;
  }

  Stdin _stdin;
  StreamSubscription _stdinSubscription;
  IOSink _stdout;
  final String prompt;
  bool _promptShown = true;
  final CommandCompleter completer;
  TermInfo _term = new TermInfo();

  // TODO(turnidge): See if we can get screen resize events.
  int _screenWidth;
  List<int> _currentLine = [];  // A list of runes.
  StringBuffer _bufferedInput = new StringBuffer();
  List<List<int>> _lines = [];

  // When using the command history, the current line is temporarily
  // added to the history to allow the user to return to it.  This
  // values tracks whether the history has a temporary line at the end.
  bool _tempLineAdded = false;
  int _linePos = 0;
  int _cursorPos = 0;
  int _tabCount = 0;
  List<int> _killBuffer = [];
}


// Demo code.


List<String> _myCompleter(List<String> commandTokens) {
  List<String> completions = new List<String>();

  // First word completions.
  if (commandTokens.length <= 1) {
    String prefix = '';
    if (commandTokens.length == 1) {
      prefix = commandTokens.first;
    }
    if ('quit'.startsWith(prefix)) {
      completions.add('quit');
    }
    if ('help'.startsWith(prefix)) {
      completions.add('help');
    }
    if ('happyface'.startsWith(prefix)) {
      completions.add('happyface');
    }
  }

  // Complete 'foobar' or 'gondola' anywhere in string.
  String lastWord = commandTokens.last;
  if ('foobar'.startsWith(lastWord)) {
    completions.add('foobar');
  }
  if ('gondola'.startsWith(lastWord)) {
    completions.add('gondola');
  }

  return completions;
}


int _helpCount = 0;
Commando cmdo;


void _handleCommand(String rawCommand) {
  String command = rawCommand.trim();
  cmdo.hide();
  if (command == 'quit') {
    cmdo.close().then((_) {
        print('Exiting');
      });
  } else if (command == 'help') {
    switch (_helpCount) {
      case 0:
        print('I will not help you.');
        break;
      case 1:
        print('I mean it.');
        break;
      case 2:
        print('Seriously.');
        break;
      case 100:
        print('Well now.');
        break;
      default:
        print("Okay.  Type 'quit' to quit");
        break;
    }
    _helpCount++;
  } else if (command == 'happyface') {
    print(':-)');
  } else {
    print('Received command($command)');
  }
  cmdo.show();
}


void main() {
  print('[Commando demo]');
  cmdo = new Commando(completer:_myCompleter);
  cmdo.commands.listen(_handleCommand);
}