"""
 sshConnection Class for connecting and performing operation on
 remote server using SSH Protocol.
"""
import paramiko
import pdb
import time

class SshConnection():
    
    def __init__(self):
        self._connection = None 
        self._connection = paramiko.SSHClient()

    def connect(self, host, user=None, password=None):
        """
        Objective:
            SSH to Server "host" as User "user"

        Parameter:
            host: Server IP Address 
            user: Login Username
            password: Login password

        Return:
            Success: 0
            Failure: 1
        """  
        self._connection.set_missing_host_key_policy(paramiko.AutoAddPolicy())

        if user == None:
            user = "root"

        if password == None:
            password = "syst3m"

        try:
            self._connection.connect(host, username=user, password=password)

        except paramiko.BadHostKeyException as result:
            print(
                "BadHostKeyException: Unable to Connect to Server: '" + host + 
                "' as User: '" + user + "'")
            return 1

        except paramiko.AuthenticationException:
            print("AuthenticationException: Unable to Authenticate "
                            + user + "@" + host)
            return 1

        except paramiko.SSHException:
            print("SSHException: Unknown server " + host)
            return 1      

        return 0

    def close(self):
        """
        Objective:
            Close SSH Connections 
        """
        self._connection.close()
        return 

    def executecommand(self, command, commandInput=None):
        """
        Objective:
            Execute Command "comamnd" 

        Parameters:
            command: command to execute

        Return:
            Success: 0
            Failure: 1
        """
        output = {}
        output["exitstatus"] = None
        output["stdoutdata"] = None
        output["stderrdata"] = None
        exit_status_ready_flag = True
                        
        try:
            transport = self._connection.get_transport()
            channel = transport.open_session()
            channel.exec_command(command)
            # Adding sleep to get the correct exit_status.
            time.sleep(5)
            exit_status_ready_flag = channel.exit_status_ready()
            if not exit_status_ready_flag:
                stdin = channel.makefile("wb")

                if commandInput:
                    stdin.write(commandInput)
                else:
                    print "This command requirs Command Input \
                            after executing comamnd for command completion"
                    stdin.write("\n")
                    return output
                
            stdout = channel.makefile("rb")
            stderr = channel.makefile_stderr("rb")
            exit_status = channel.recv_exit_status()

            output["exitstatus"] = exit_status
            output["stdoutdata"] = stdout.readlines()
            output["stderrdata"] = stderr.readlines()

        except paramiko.SSHException:
            print("Unable to Execute Command: " + command)

        return output