"""Query Meshify for data."""
import json
import csv
from os import getenv
import getpass
import pickle
from pathlib import Path
import requests
import click


MESHIFY_BASE_URL = "https://194.p2121.net/api/" #getenv("MESHIFY_BASE_URL")
MESHIFY_USERNAME = "reportuser@henrypump.com" #getenv("MESHIFY_USERNAME")
MESHIFY_PASSWORD = "Kk8kMU2cc6vqVy" #getenv("MESHIFY_PASSWORD")
MESHIFY_AUTH = None


class NameNotFound(Exception):
    """Thrown when a name is not found in a list of stuff."""

    def __init__(self, message, name, list_of_stuff, *args):
        """Initialize the NameNotFound Exception."""
        self.message = message
        self.name = name
        self.list_of_stuff = list_of_stuff
        super(NameNotFound, self).__init__(message, name, list_of_stuff, *args)


def dict_filter(it, *keys):
    """Filter dictionary results."""
    for d in it:
        yield dict((k, d[k]) for k in keys)


def check_setup():
    """Check the global parameters."""
    global MESHIFY_USERNAME, MESHIFY_PASSWORD, MESHIFY_AUTH, MESHIFY_BASE_URL
    if not MESHIFY_USERNAME or not MESHIFY_PASSWORD:
        print("Simplify the usage by setting the meshify username and password as environment variables MESHIFY_USERNAME and MESHIFY_PASSWORD")
        MESHIFY_USERNAME = input("Meshify Username: ")
        MESHIFY_PASSWORD = getpass.getpass("Meshify Password: ")

    MESHIFY_AUTH = requests.auth.HTTPBasicAuth(MESHIFY_USERNAME, MESHIFY_PASSWORD)

    if not MESHIFY_BASE_URL:
        print("Simplify the usage by setting the environment variable MESHIFY_BASE_URL")
        MESHIFY_BASE_URL = input("Meshify Base URL: ")


def find_by_name(name, list_of_stuff):
    """Find an object in a list of stuff by its name parameter."""
    for x in list_of_stuff:
        if x['name'] == name:
            return x
    raise NameNotFound("Name not found!", name, list_of_stuff)


def GET(endpoint):
    """Make a query to the meshify API."""
    check_setup()
    if endpoint[0] == "/":
        endpoint = endpoint[1:]
    q_url = MESHIFY_BASE_URL + endpoint
    q_req = requests.get(q_url, auth=MESHIFY_AUTH)
    return json.loads(q_req.text) if q_req.status_code == 200 else []


def post_meshify_api(endpoint, data):
    """Post data to the meshify API."""
    check_setup()
    q_url = MESHIFY_BASE_URL + endpoint
    q_req = requests.post(q_url, data=json.dumps(data), auth=MESHIFY_AUTH)
    if q_req.status_code != 200:
        print(q_req.status_code)
    return json.loads(q_req.text) if q_req.status_code == 200 else []


def getNodeTypes():
    return GET("nodetypes")

def getNodes():
    return GET("nodes")

def getFolders():
    return GET("folders")

def getChannelValues(nodeId):
    return GET("data/current?nodeId={}".format(nodeId))

def getUsers():
    return GET("users")

def decode_channel_parameters(channel):
    """Decode a channel object's parameters into human-readable format."""
    channel_types = {
        1: 'device',
        5: 'static',
        6: 'user input',
        7: 'system'
    }

    io_options = {
        0: 'readonly',
        1: 'readwrite'
    }

    datatype_options = {
        1: "float",
        2: 'string',
        3: 'integer',
        4: 'boolean',
        5: 'datetime',
        6: 'timespan',
        7: 'file',
        8: 'latlng'
    }

    channel['channelType'] = channel_types[channel['channelType']]
    channel['io'] = io_options[channel['io']]
    channel['dataType'] = datatype_options[channel['dataType']]
    return channel


def encode_channel_parameters(channel):
    """Encode a channel object from human-readable format."""
    channel_types = {
        'device': 1,
        'static': 5,
        'user input': 6,
        'system': 7
    }

    io_options = {
        'readonly': False,
        'readwrite': True
    }

    datatype_options = {
        "float": 1,
        'string': 2,
        'integer': 3,
        'boolean': 4,
        'datetime': 5,
        'timespan': 6,
        'file': 7,
        'latlng': 8
    }
    try:
        channel['deviceTypeId'] = int(channel['deviceTypeId'])
        channel['fromMe'] = channel['fromMe'].lower() == 'true'
        channel['channelType'] = channel_types[channel['channelType'].lower()]
        channel['io'] = io_options[channel['io'].lower()]
        channel['dataType'] = datatype_options[channel['dataType'].lower()]
        # channel['id'] = 1
        return channel
    except KeyError as e:
        click.echo("Unable to convert channel {} due to bad key: {}".format(channel['name'], e))


def make_modbusmap_channel(i, chan, device_type_name):
    """Make a channel object for a row in the CSV."""
    json_obj = {
        "ah": "",
        "bytary": None,
        "al": "",
        "vn": chan['subTitle'],  # Name
        "ct": "number",  # ChangeType
        "le": "16",   # Length(16 or 32)
        "grp": str(chan['guaranteedReportPeriod']),  # GuaranteedReportPeriod
        "la": None,
        "chn": chan['name'],  # ChannelName
        "un": "1",  # DeviceNumber
        "dn": device_type_name,  # deviceName
        "vm": None,
        "lrt": "0",
        "da": "300",  # DeviceAddress
        "a": chan['helpExplanation'],  # TagName
        "c": str(chan['change']),  # Change
        "misc_u": str(chan['units']),  # Units
        "f": "1",  # FunctionCode
        "mrt": str(chan['minReportTime']),  # MinimumReportTime
        "m": "none",  # multiplier
        "m1ch": "2-{}".format(i),
        "mv": "0",  # MultiplierValue
        "s": "On",
        "r": "{}-{}".format(chan['min'], chan['max']),  # range
        "t": "int"  # type
    }
    return json_obj


def combine_modbusmap_and_channel(channel_obj, modbus_map):
    """Add the parameters from the modbus map to the channel object."""
    channel_part = modbus_map["1"]["addresses"]["300"]
    for c in channel_part:
        if channel_part[c]["chn"] == channel_obj['name']:
            channel_obj['units'] = channel_part[c]["misc_u"]
            try:
                min_max_range = channel_part[c]["r"].split("-")
                channel_obj['min'] = int(min_max_range[0])
                channel_obj['max'] = int(min_max_range[1])
            except Exception:
                channel_obj['min'] = None
                channel_obj['max'] = None

            channel_obj['change'] = float(channel_part[c]["c"])
            channel_obj['guaranteedReportPeriod'] = int(channel_part[c]["grp"])
            channel_obj['minReportTime'] = int(channel_part[c]["mrt"])
            return channel_obj
    return False


@click.group()
def cli():
    """Command Line Interface."""
    pass


@click.command()
@click.argument("device_type_name")
@click.option("-o", '--output-file', default=None, help="Where to put the CSV of channels.")
@click.option("-m", '--modbusmap-file', default="modbusMap.p", help="The location of the modbusMap.p file")
def get_channel_csv(device_type_name, output_file, modbusmap_file):
    """Query the meshify API and create a CSV of the current channels."""
    channel_fieldnames = [
        'id',
        'name',
        'deviceTypeId',
        'fromMe',
        'io',
        'subTitle',
        'helpExplanation',
        'channelType',
        'dataType',
        'defaultValue',
        'regex',
        'regexErrMsg',
        'units',
        'min',
        'max',
        'change',
        'guaranteedReportPeriod',
        'minReportTime'
    ]
    devicetypes = GET('devicetypes')
    this_devicetype = find_by_name(device_type_name, devicetypes)
    channels = GET('devicetypes/{}/channels'.format(this_devicetype['id']))
    modbus_map = None

    if Path(modbusmap_file).exists():
        with open(modbusmap_file, 'rb') as open_mbs_file:
            modbus_map = pickle.load(open_mbs_file)

    if not output_file:
        output_file = 'channels_{}.csv'.format(device_type_name)

    with open(output_file, 'w') as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=channel_fieldnames)

        writer.writeheader()
        for ch in channels:
            if not modbus_map:
                ch['units'] = None
                ch['min'] = None
                ch['max'] = None
                ch['change'] = None
                ch['guaranteedReportPeriod'] = None
                ch['minReportTime'] = None
            else:
                combined = combine_modbusmap_and_channel(ch, modbus_map)
                if combined:
                    ch = combined
            writer.writerow(decode_channel_parameters(ch))

    click.echo("Wrote channels to {}".format(output_file))


@click.command()
@click.argument("device_type_name")
@click.argument("csv_file")
def post_channel_csv(device_type_name, csv_file):
    """Post values from a CSV to Meshify Channel API."""
    devicetypes = GET('devicetypes')
    this_devicetype = find_by_name(device_type_name, devicetypes)

    with open(csv_file, 'r') as inp_file:
        reader = csv.DictReader(inp_file)
        for row in dict_filter(reader, 'name',
                               'deviceTypeId',
                               'fromMe',
                               'io',
                               'subTitle',
                               'helpExplanation',
                               'channelType',
                               'dataType',
                               'defaultValue',
                               'regex',
                               'regexErrMsg'):
            # print(row)
            # print(encode_channel_parameters(row))
            # click.echo(json.dumps(encode_channel_parameters(row), indent=4))
            if post_meshify_api('devicetypes/{}/channels'.format(this_devicetype['id']), encode_channel_parameters(row)):
                click.echo("Successfully added channel {}".format(row['name']))
            else:
                click.echo("Unable to add channel {}".format(row['name']))


@click.command()
def print_channel_options():
    """Print channel options for use with the csv files."""
    channel_types = ['device', 'static', 'user input', 'system']
    io_options = ['readonly', 'readwrite']
    datatype_options = [
        "float",
        'string',
        'integer',
        'boolean',
        'datetime',
        'timespan',
        'file',
        'latlng'
    ]

    click.echo("\n\nchannelType options")
    click.echo("===================")
    for chan in channel_types:
        click.echo(chan)

    click.echo("\n\nio options")
    click.echo("==========")
    for i in io_options:
        click.echo(i)

    click.echo("\n\ndataType options")
    click.echo("================")
    for d in datatype_options:
        click.echo(d)


@click.command()
@click.argument("device_type_name")
@click.argument("csv_file")
def create_modbusMap(device_type_name, csv_file):
    """Create modbusMap.p from channel csv file."""
    modbusMap = {
        "1": {
            "c": "ETHERNET/IP",
            "b": "192.168.1.10",
            "addresses": {
                "300": {}
            },
            "f": "Off",
            "p": "",
            "s": "1"
        },
        "2": {
            "c": "M1-485",
            "b": "9600",
            "addresses": {},
            "f": "Off",
            "p": "None",
            "s": "1"
        }
    }
    ind = 1
    with open(csv_file, 'r') as inp_file:
        reader = csv.DictReader(inp_file)
        for row in reader:
            modbusMap["1"]["addresses"]["300"]["2-{}".format(ind)] = make_modbusmap_channel(ind, row, device_type_name)
            ind += 1
    with open("modbusMap.p", 'wb') as mod_map_file:
        pickle.dump(modbusMap, mod_map_file, protocol=0)

    with open("modbusMap.json", 'w') as json_file:
        json.dump(modbusMap, json_file, indent=4)


@click.command()
@click.option("-i", "--input-file", default="modbusMap.p", help="The modbus map pickle file to convert.")
@click.option("-o", "--output", default="modbusMap.json", help="The modbus map json file output filename.")
def pickle_to_json(input_file, output):
    """Convert a pickle file to a json file."""
    if not Path(input_file).exists():
        click.echo("Pickle file {} does not exist".format(input_file))
        return

    with open(input_file, 'rb') as picklefile:
        input_contents = pickle.load(picklefile)

        with open(output, 'w') as outfile:
            json.dump(input_contents, outfile, indent=4)
            click.echo("Wrote from {} to {}.".format(input_file, output))

@click.command()
@click.option("-i", "--input-file", default="modbusMap.json", help="The modbus map json file to convert.")
@click.option("-o", "--output", default="modbusMap.p", help="The modbus map pickle file output filename.")
def json_to_pickle(input_file, output):
    """Convert a pickle file to a json file."""
    if not Path(input_file).exists():
        click.echo("JSON file {} does not exist".format(input_file))
        return

    with open(input_file, 'rb') as json_file:
        input_contents = json.load(json_file)

        with open(output, 'wb') as outfile:
            pickle.dump(input_contents, outfile, protocol=0)
            click.echo("Wrote from {} to {}.".format(input_file, output))


cli.add_command(get_channel_csv)
cli.add_command(post_channel_csv)
cli.add_command(print_channel_options)
cli.add_command(create_modbusMap)
cli.add_command(pickle_to_json)
cli.add_command(json_to_pickle)

if __name__ == '__main__':
    cli()