#!/usr/bin/python3
"""
Create a folder.

Example:
    grouper_create_folder.py -m dev -f this:is:parent -g newfolder -n 'New Folder' -d 'Some description'
"""

import argparse
import requests
from requests.auth import HTTPBasicAuth
import json
import sys,string

def grouperCreateFolder(grouper_credentials, grouper_ws_uri, parentIdPath, folderId, folderName, folderDescription):
    """Create folder"""
    folderIdPath = parentIdPath+':'+folderId
    body = {
      "WsRestStemSaveRequest":{
          "wsStemToSaves":[
              {
                  "wsStemLookup":{
                      "stemName": folderIdPath
                  },
                  "wsStem":{
                      "extension": folderId,
                      "displayExtension": folderName,
                      "name": folderIdPath,
                      "description": folderDescription
                  }
              }
          ]
      }
    }
    return grouperWSRequest(grouper_credentials, grouper_ws_uri+"/stems", "POST", body)

def grouperGetFolderUuid(grouper_credentials, grouper_ws_uri, folderName):
    """Get UUID for the specified folder"""
    thisuuid = 0
    body = {
        "WsRestFindStemsRequest": {
            "wsStemQueryFilter": {
                "stemName": folderName,
                "stemQueryFilterType": "FIND_BY_STEM_NAME"
            }
        }
    }
    findStems = grouperWSRequest(grouper_credentials, grouper_ws_uri + "/stems", "POST", body)
    if findStems and findStems['WsFindStemsResults']['resultMetadata']['success']:
        stemList = findStems['WsFindStemsResults']['stemResults']
        if len(stemList) == 1:
            thisuuid = findStems['WsFindStemsResults']['stemResults'][0]['uuid']
    return thisuuid

def grouperGetUuid(grouper_credentials, grouper_ws_uri, groupName):
    """Get UUID for the specified group"""
    thisuuid = 0
    body = {
        "WsRestFindGroupsRequest": {
            "wsQueryFilter": {
                "groupName": groupName,
                "queryFilterType": "FIND_BY_GROUP_NAME_EXACT",
            }
        }
    }
    findGroups = grouperWSRequest(grouper_credentials, grouper_ws_uri+"/groups", "POST", body)
    if findGroups and findGroups['WsFindGroupsResults']['resultMetadata']['success'] and 'groupResults' in findGroups['WsFindGroupsResults']:
        thisuuid = findGroups['WsFindGroupsResults']['groupResults'][0]['uuid']
    return thisuuid

def grouperWSRequest(grouper_credentials, url, method, body=None):
    """Send a request to the Grouper Web Service."""
    try:
        response = requests.request(method, url, json=body, auth=grouper_credentials)
        response.raise_for_status()
    except requests.RequestException as e:
        raise SystemExit(e) from None

    return response.json()

def create_folder(mode, parent_folder, folder_id, folder_name, folder_description):
    """Create folder.

    Args:
        mode (str): The environment mode ('dev', 'prod').
        parent_folder (str): The parent folder.
        folder_id (str): The folder ID.
        folder_name (str): The folder name.
        folder_description (str): The folder description.
    """
    # set the Grouper Web Service username and password
    grouper_username = 'abc1234'
    grouper_password = 'xxxxxxxxxxxxxxxxxxxx'
    grouper_credentials = HTTPBasicAuth(grouper_username,grouper_password)

    # the Grouper Web Service URI should point to dev or prod Grouper
    devGrouperURI  = 'https://grouper-dev.cc.columbia.edu/grouper-ws/servicesRest/v2_4_000'
    prodGrouperURI = 'https://grouper.cc.columbia.edu/grouper-ws/servicesRest/v2_4_000'
    if mode == 'prod':
        grouper_ws_uri = prodGrouperURI
    else:
        grouper_ws_uri = devGrouperURI

    # Verify that the parent folder exists and is accessible by this user
    if grouperGetFolderUuid(grouper_credentials,grouper_ws_uri,parent_folder) == 0:
        print(f"{parent_folder} folder not found (does not exist or is not accessible)")
        return

    # create a folder
    result = grouperCreateFolder(grouper_credentials,grouper_ws_uri,parent_folder,folder_id,folder_name,folder_description)
    if not result:
        print(f"Unable to create {folder_id} in {parent_folder}")
        return
    if not result['WsStemSaveResults']['resultMetadata']['resultCode'] == 'SUCCESS':
        rc = result['WsStemSaveResults']['resultMetadata']['resultCode']
        print(f"Unable to create {folder_id} in {parent_folder} result code {rc}")
        return

    result_code = result['WsStemSaveResults']['results'][0]['resultMetadata']['resultCode']
    if result_code == 'SUCCESS_NO_CHANGES_NEEDED':
        print(f"{folder_id} folder already exists")
    elif result_code == 'SUCCESS_UPDATED':
        print(f"{folder_id} folder already exists, it has been updated")
    elif result_code == 'SUCCESS_INSERTED':
        print(f"{folder_id} folder created")
    else:
        print(f"{folder_id} folder created, {result_code}")

def main():
    """Parses command-line arguments and calls create_folder."""
    parser = argparse.ArgumentParser(
        description="Create a folder.",
    )
    parser.add_argument(
        "-m",
        action="store",
        dest="mode",
        required=True,
        choices=["dev", "prod"],
        type=str.lower,
        help="the Grouper environment mode",
    )
    parser.add_argument(
        "-f",
        action="store",
        dest="parent_folder",
        required=True,
        help="the parent folder",
    )
    parser.add_argument(
        "-g",
        action="store",
        dest="folder_id",
        required=True,
        help="the folder ID",
    )
    parser.add_argument(
        "-n",
        action="store",
        dest="folder_name",
        required=True,
        help="the folder name",
    )
    parser.add_argument(
        "-d",
        action="store",
        dest="folder_description",
        required=True,
        help="the folder description",
    )
    args = parser.parse_args()

    create_folder(args.mode, args.parent_folder, args.folder_id, args.folder_name, args.folder_description)

if __name__ == "__main__":
    main()