#! /usr/bin/python2
 #
 #    Copyright (C) 2015 vmware inc.
 #
 #    Author: Mahmoud Bassiouny <mbassiouny@vmware.com>
 

 from optparse import OptionParser
 import os.path

 import curses
 import sys

 import subprocess
 import re
 import requests
 import json
 import time
 import os

 import cracklib
 import crypt
 import string
 import random

 import urllib

 import urllib2

 import modules.commons

 from diskpartitioner import DiskPartitioner
 from packageselector import PackageSelector
 from custompackageselector import CustomPackageSelector
 from installer import Installer

 from installercontainer import InstallerContainer
 from ostreeinstaller import OstreeInstaller

 from windowstringreader import WindowStringReader

 from ostreewindowstringreader import OSTreeWindowStringReader

 from jsonwrapper import JsonWrapper
 from selectdisk import SelectDisk

 from license import License

 from ostreeserverselector import OSTreeServerSelector

 
 class IsoInstaller(object):

     def get_config(self, path):
         if path.startswith("http://"):

             # Do 5 trials to get the kick start

             # TODO: make sure the installer run after network is up

             wait = 1
             for x in range(0,5):

                 err_msg = ""
                 try:
                     response = requests.get(path, timeout=3)
                     if response.ok:
                         return json.loads(response.text)
                     err_msg = response.text
                 except Exception as e:
                     err_msg = e

                 modules.commons.log(modules.commons.LOG_ERROR, "Failed to get the kickstart file at {0}, error msg: {1}".format(path, err_msg))

                 print "Failed to get the kickstart file at {0}, retry in a second".format(path)

                 time.sleep(wait)
                 wait = wait * 2

 
 
             # Something went wrong
             print "Failed to get the kickstart file at {0}, exiting the installer, check the logs for more details".format(path)
             raise Exception(err_msg)
         else:
             if path.startswith("cdrom:/"):

                 self.mount_RPMS_cd()
                 path = os.path.join(self.cd_path, path.replace("cdrom:/", "", 1))

             return (JsonWrapper(path)).read();
 
     def mount_RPMS_cd(self):

         # check if the cd is already mounted
         if self.cd_path:
             return
 

         # Mount the cd to get the RPMS
         process = subprocess.Popen(['mkdir', '-p', '/mnt/cdrom'])
         retval = process.wait()
 
         # Retry mount the CD
         for i in range(0,3):
             process = subprocess.Popen(['mount', '/dev/cdrom', '/mnt/cdrom'])
             retval = process.wait()
             if retval == 0:

                 self.cd_path = "/mnt/cdrom"
                 return

             print "Failed to mount the cd, retry in a second"
             time.sleep(1)
         print "Failed to mount the cd, exiting the installer, check the logs for more details"
         raise Exception("Can not mount the cd")

 
     def validate_hostname(self, hostname):

         error_empty = "Empty hostname or domain is not allowed"
         error_dash = "Hostname or domain should not start or end with '-'"
         error_hostname = "Hostname should start with alpha char and <= 64 chars"
 

         if (hostname == None or len(hostname) == 0):

             return False, error_empty
 
         fields = hostname.split('.')
         for field in fields:
             if len(field) == 0:
                 return False, error_empty
             if field[0] == '-' or field[-1] == '-':
                 return False, error_dash
 
         machinename = fields[0]
         return (len(machinename) <= 64) and (ord(machinename[0]) in self.alpha_chars), error_hostname

     def validate_ostree_url_input(self, ostree_repo_url):
         if not ostree_repo_url:

             return False, "Error: Invalid input"

         exception_text = "Error: Invalid or unreachable URL"
         error_text = "Error: Repo URL not accessible"
         ret = self.validate_http_response(ostree_repo_url, [], exception_text, error_text)
         if ret != "":
             return False, ret

         exception_text = "Error: Invalid repo - missing config"
         ret = self.validate_http_response(
             ostree_repo_url + "/config",
             [ [".*\[core\]\s*", 1, "Error: Invalid config - 'core' group expected" ],
               ["\s*mode[ \t]*=[ \t]*archive-z2[^ \t]", 1, "Error: can't pull from repo in 'bare' mode, 'archive-z2' mode required" ] ],
             exception_text, exception_text)
         if ret != "":
             return False, ret
     
         exception_text = "Error: Invalid repo - missing refs"
         ret = self.validate_http_response(ostree_repo_url + "/refs/heads", [], exception_text, exception_text)
         if ret != "":
             return False, ret
 
         exception_text = "Error: Invalid repo - missing objects"
         ret = self.validate_http_response(ostree_repo_url + "/objects", [], exception_text, exception_text)
         if ret != "":
             return False, ret
 
         self.ostree_repo_url = ostree_repo_url

 
         return True, None
 

     def validate_ostree_refs_input(self, ostree_repo_ref):
         if not ostree_repo_ref:
             return False, "Error: Invalid input"
 
         ret = self.validate_http_response(
                 self.ostree_repo_url  + '/refs/heads/' + ostree_repo_ref,
                 [ ["^\s*[0-9A-Fa-f]{64}\s*$", 1, "Error: Incomplete Refspec path, or unexpected Refspec format"] ],
                 "Error: Invalid Refspec path",
                 "Error: Refspec not accessible")
         if ret != "":
             return False, ret
 
         return True, None

     def validate_password(self, text):
         try:
             p = cracklib.VeryFascistCheck(text)
         except ValueError, message:
             p = str(message)
         return p == text, "Error: " + p
 
     def generate_password_hash(self,  password):
         shadow_password = crypt.crypt(password, "$6$" + "".join([random.choice(string.ascii_letters + string.digits) for _ in range(16)]))
         return shadow_password
 

     def validate_http_response(self, url, checks, exception_text, error_text):
         try:
             if url.startswith("https"):
                 response = urllib2.urlopen(url,cafile="/usr/lib/python2.7/site-packages/requests/cacert.pem")
             else:
                 response = urllib2.urlopen(url)
 
         except:
             return exception_text
         else:
             if response.getcode() != 200:
                 return error_text
         
         html = response.read()
         
         for pattern, count, failed_check_text in checks:
             match = re.findall(pattern, html)
             if len(match) != count:
                 return failed_check_text
 
         return ""
 

     def __init__(self, stdscreen, options_file):

         self.screen = stdscreen
 
         # Init the colors
         curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
         curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_WHITE)
         curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_GREEN)
         curses.init_pair(4, curses.COLOR_RED, curses.COLOR_WHITE)
 
         self.screen.bkgd(' ', curses.color_pair(1))
 
         self.maxy,  self.maxx = self.screen.getmaxyx()
         self.screen.addstr(self.maxy - 1, 0, '<Tab> moves; <Space> selects; <Enter> forward')
 
         curses.curs_set(0)
 

         self.cd_path = None;

         
         kernel_params = subprocess.check_output(['cat', '/proc/cmdline'])

 
         # check the kickstart param
         ks_config = None

         m = re.match(r".*ks=(\S+)\s*.*\s*", kernel_params)
         if m != None:

             ks_config = self.get_config(m.group(1))
 
         # check for the repo param
         m = re.match(r".*repo=(\S+)\s*.*\s*", kernel_params)
         if m != None:
             rpm_path = m.group(1)
         else:
             # the rpms should be in the cd
             self.mount_RPMS_cd()
             rpm_path=os.path.join(self.cd_path, "RPMS")

 
         # This represents the installer screen, the bool indicated if I can go back to this window or not

         items = []
         if not ks_config:

             random_id = '%12x' % random.randrange(16**12)
             random_hostname = "photon-" + random_id.strip()

             install_config = {'iso_system': False}

             license_agreement = License(self.maxy, self.maxx)

             select_disk = SelectDisk(self.maxy, self.maxx, install_config)
             package_selector = PackageSelector(self.maxy, self.maxx, install_config, options_file)

 
             self.alpha_chars = range(65, 91)
             self.alpha_chars.extend(range(97,123))
             hostname_accepted_chars = list(self.alpha_chars)
             # Adding the numeric chars
             hostname_accepted_chars.extend(range(48, 58))
             # Adding the . and -
             hostname_accepted_chars.extend([ord('.'), ord('-')])
             
             hostname_reader = WindowStringReader(
                     self.maxy, self.maxx, 10, 70, 
                     'hostname', 
                     None, # confirmation error msg if it's a confirmation text
                     None, # echo char
                     hostname_accepted_chars, # set of accepted chars
                     self.validate_hostname, # validation function of the input
                     None, # post processing of the input field
                     'Choose the hostname for your system', 'Hostname:', 2, install_config,
                     random_hostname)
             root_password_reader = WindowStringReader(
                     self.maxy, self.maxx, 10, 70, 
                     'password', 
                     None, # confirmation error msg if it's a confirmation text
                     '*', # echo char
                     None, # set of accepted chars
                     self.validate_password, # validation function of the input
                     None,  # post processing of the input field
                     'Set up root password', 'Root password:', 2, install_config)
             confirm_password_reader = WindowStringReader(
                     self.maxy, self.maxx, 10, 70, 
                     'password', 
                     "Passwords don't match, please try again.", # confirmation error msg if it's a confirmation text
                     '*', # echo char
                     None, # set of accepted chars
                     None, # validation function of the input
                     self.generate_password_hash, # post processing of the input field
                     'Confirm root password', 'Confirm Root password:', 2, install_config)
             ostree_server_selector = OSTreeServerSelector(self.maxy, self.maxx, install_config)
             ostree_url_reader = OSTreeWindowStringReader(
                     self.maxy, self.maxx, 10, 80, 
                     'ostree_repo_url', 
                     None, # confirmation error msg if it's a confirmation text
                     None, # echo char
                     None, # set of accepted chars

                     self.validate_ostree_url_input, # validation function of the input

                     None, # post processing of the input field
                     'Please provide the URL of OSTree repo', 'OSTree Repo URL:', 2, install_config,

                     "http://")

             ostree_ref_reader = OSTreeWindowStringReader(
                     self.maxy, self.maxx, 10, 70, 
                     'ostree_repo_ref', 
                     None, # confirmation error msg if it's a confirmation text
                     None, # echo char
                     None, # set of accepted chars

                     self.validate_ostree_refs_input, # validation function of the input

                     None, # post processing of the input field

                     'Please provide the Refspec in OSTree repo', 'OSTree Repo Refspec:', 2, install_config,
                     "photon/1.0/x86_64/minimal")

             items = items + [

                     (license_agreement.display, False),
                     (select_disk.display, True),

                     (package_selector.display, True),
                     (hostname_reader.get_user_string, True),
                     (root_password_reader.get_user_string, True),

                     (confirm_password_reader.get_user_string, False),

                     (ostree_server_selector.display, True),
                     (ostree_url_reader.get_user_string, True),
                     (ostree_ref_reader.get_user_string, True),

                  ]

         else:
             install_config = ks_config
             install_config['iso_system'] = False
 
         installer = InstallerContainer(install_config, self.maxy, self.maxx, True, rpm_path=rpm_path, log_path="/var/log", ks_config=ks_config)

         items = items + [(installer.install, False)]

 
         index = 0
         params = None
         while True:
             result = items[index][0](params)
             if result.success:
                 index += 1
                 params = result.result
                 if index == len(items):
                     break
             else:
                 index -= 1
                 while index >= 0 and items[index][1] == False:
                     index -= 1
                 if index < 0:
                     index = 0
 
 if __name__ == '__main__':

     usage = "Usage: %prog [options]"
     parser = OptionParser(usage)
     parser.add_option("-j",  "--json-file", dest="options_file",  default="input.json")
 
     (options,  args) = parser.parse_args()
     curses.wrapper(IsoInstaller, options.options_file)