#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Standalone Meteostick reader script
Based on the meteostick.py weewx driver

This script opens a Meteostick device, initializes it, and continuously
prints the raw messages received from Davis weather stations.
Can also send data to InfluxDB for storage and visualization.
"""

import time
import sys
import optparse
import math
import string
import os

try:
    import serial
except ImportError:
    print("Error: pyserial module is required. Install with: pip install pyserial")
    sys.exit(1)

try:
    from influxdb import InfluxDBClient
    INFLUXDB_AVAILABLE = True
except ImportError:
    INFLUXDB_AVAILABLE = False

# Simple CRC16 implementation for standalone use
def crc16(data):
    """Simple CRC16 implementation"""
    crc = 0
    for byte in data:
        crc ^= ord(byte) << 8
        for _ in range(8):
            if crc & 0x8000:
                crc = (crc << 1) ^ 0x1021
            else:
                crc <<= 1
            crc &= 0xFFFF
    return crc

# Simple logging functions
def logdbg(msg):
    print(f"DEBUG: {msg}")

def loginf(msg):
    print(f"INFO: {msg}")

def logerr(msg):
    print(f"ERROR: {msg}")

# Constants from meteostick.py
DEBUG_SERIAL = 0
DEBUG_RAIN = 0
DEBUG_PARSE = 0
MPH_TO_MPS = 1609.34 / 3600.0 # meter/mile * hour/second
DEFAULT_SOIL_TEMP = 24 # C

RAW = 0  # indices of table with raw values
POT = 1  # indices of table with potentials

# Lookup tables
SM_MAP = {RAW: ( 99.2, 140.1, 218.7, 226.9, 266.8, 391.7, 475.6, 538.2, 596.1, 673.7, 720.1),
          POT: (  0.0,   1.0,   9.0,  10.0,  15.0,  35.0,  55.0,  75.0, 100.0, 150.0, 200.0)}

LW_MAP = {RAW: (857.0, 864.0, 895.0, 911.0, 940.0, 952.0, 991.0, 1013.0),
          POT: ( 15.0,  14.0,   5.0,   4.0,   3.0,   2.0,   1.0,    0.0)}

def dbg_serial(verbosity, msg):
    if DEBUG_SERIAL >= verbosity:
        logdbg(msg)

def dbg_parse(verbosity, msg):
    if DEBUG_PARSE >= verbosity:
        logdbg(msg)

def _fmt(data):
    if not data:
        return ''
    return ' '.join(['%02x' % int(ord(x)) for x in data])

def calculate_thermistor_temp(temp_raw):
    """Calculate thermistor temperature using Davis formulas."""
    # Convert temp_raw to a resistance (R) in kiloOhms
    a = 18.81099
    b = 0.0009988027
    r = a / (1.0 / temp_raw - b) / 1000 # k ohms

    # Steinhart-Hart parameters
    s1 = 0.002783573
    s2 = 0.0002509406
    try:
        thermistor_temp = 1 / (s1 + s2 * math.log(r)) - 273
        dbg_parse(3, 'r (k ohm) %s temp_raw %s thermistor_temp %s' %
                  (r, temp_raw, thermistor_temp))
        return thermistor_temp
    except ValueError as e:
        logerr('thermistor_temp failed for temp_raw %s r (k ohm) %s error: %s' % (temp_raw, r, e))
    return DEFAULT_SOIL_TEMP

def lookup_potential(sensor_name, norm_fact, sensor_raw, sensor_temp, lookup):
    """Look up potential based upon a normalized raw value."""
    # normalize raw value for standard temperature (DEFAULT_SOIL_TEMP)
    sensor_raw_norm = sensor_raw * (1 + norm_fact * (sensor_temp - DEFAULT_SOIL_TEMP))

    numcols = len(lookup[RAW])
    if sensor_raw_norm >= lookup[RAW][numcols - 1]:
        potential = lookup[POT][numcols - 1] # preset potential to last value
        dbg_parse(3, "%s: temp=%s fact=%s raw=%s norm=%s potential=%s >= RAW=%s" %
                  (sensor_name, sensor_temp, norm_fact, sensor_raw,
                   sensor_raw_norm, potential, lookup[RAW][numcols - 1]))
    else:
        potential = lookup[POT][0] # preset potential to first value
        # lookup sensor_raw_norm value in table
        for x in range(0, numcols):
            if sensor_raw_norm < lookup[RAW][x]:
                if x == 0:
                    # 'pre zero' phase; potential = first value
                    dbg_parse(3, "%s: temp=%s fact=%s raw=%s norm=%s potential=%s < RAW=%s" %
                              (sensor_name, sensor_temp, norm_fact, sensor_raw,
                               sensor_raw_norm, potential, lookup[RAW][0]))
                    break
                else:
                    # determine the potential value
                    potential_per_raw = (lookup[POT][x] - lookup[POT][x - 1]) / (lookup[RAW][x] - lookup[RAW][x - 1])
                    potential_offset = (sensor_raw_norm - lookup[RAW][x - 1]) * potential_per_raw
                    potential = lookup[POT][x - 1] + potential_offset
                    dbg_parse(3, "%s: temp=%s fact=%s raw=%s norm=%s potential=%s RAW=%s to %s POT=%s to %s " %
                              (sensor_name, sensor_temp, norm_fact, sensor_raw,
                               sensor_raw_norm, potential,
                               lookup[RAW][x - 1], lookup[RAW][x],
                               lookup[POT][x - 1], lookup[POT][x]))
                    break
    return potential

# Simplified Fahrenheit to Celsius conversion
def FtoC(temp_f):
    """Convert Fahrenheit to Celsius"""
    return (temp_f - 32.0) * 5.0 / 9.0

class Meteostick(object):
    DEFAULT_PORT = '/dev/ttyUSB0'
    DEFAULT_BAUDRATE = 115200
    DEFAULT_FREQUENCY = 'EU'
    DEFAULT_RF_SENSITIVITY = 90
    MAX_RF_SENSITIVITY = 125
    RAW_CHANNEL = 0  # unused channel for the receiver stats in raw format

    def __init__(self, **cfg):
        self.port = cfg.get('port', self.DEFAULT_PORT)
        loginf('using serial port %s' % self.port)

        self.baudrate = cfg.get('baudrate', self.DEFAULT_BAUDRATE)
        loginf('using baudrate %s' % self.baudrate)

        freq = cfg.get('transceiver_frequency', self.DEFAULT_FREQUENCY)
        if freq not in ['EU', 'US', 'AU']:
            raise ValueError("invalid frequency %s" % freq)
        self.frequency = freq
        loginf('using frequency %s' % self.frequency)

        rfs = int(cfg.get('rf_sensitivity', self.DEFAULT_RF_SENSITIVITY))
        absrfs = abs(rfs)
        if absrfs > self.MAX_RF_SENSITIVITY:
            raise ValueError("invalid RF sensitivity %s" % rfs)
        self.rfs = absrfs
        self.rf_threshold = absrfs * 2
        loginf('using rf sensitivity %s (-%s dB)' % (rfs, absrfs))

        channels = dict()
        channels['iss'] = int(cfg.get('iss_channel', 1))
        channels['anemometer'] = int(cfg.get('anemometer_channel', 0))
        channels['leaf_soil'] = int(cfg.get('leaf_soil_channel', 0))
        channels['temp_hum_1'] = int(cfg.get('temp_hum_1_channel', 0))
        channels['temp_hum_2'] = int(cfg.get('temp_hum_2_channel', 0))
        if channels['anemometer'] == 0:
            channels['wind_channel'] = channels['iss']
        else:
            channels['wind_channel'] = channels['anemometer']
        self.channels = channels
        loginf('using iss_channel %s' % channels['iss'])
        loginf('using anemometer_channel %s' % channels['anemometer'])
        loginf('using leaf_soil_channel %s' % channels['leaf_soil'])
        loginf('using temp_hum_1_channel %s' % channels['temp_hum_1'])
        loginf('using temp_hum_2_channel %s' % channels['temp_hum_2'])

        self.transmitters = self.ch_to_xmit(
            channels['iss'], channels['anemometer'], channels['leaf_soil'],
            channels['temp_hum_1'], channels['temp_hum_2'])
        loginf('using transmitters %02x' % self.transmitters)

        self.timeout = 3 # seconds
        self.serial_port = None

    @staticmethod
    def ch_to_xmit(iss_channel, anemometer_channel, leaf_soil_channel,
                   temp_hum_1_channel, temp_hum_2_channel):
        transmitters = 0
        transmitters += 1 << (iss_channel - 1)
        if anemometer_channel != 0:
            transmitters += 1 << (anemometer_channel - 1)
        if leaf_soil_channel != 0:
            transmitters += 1 << (leaf_soil_channel - 1)
        if temp_hum_1_channel != 0:
            transmitters += 1 << (temp_hum_1_channel - 1)
        if temp_hum_2_channel != 0:
            transmitters += 1 << (temp_hum_2_channel - 1)
        return transmitters

    @staticmethod
    def _check_crc(msg, chksum):
        crc_result = crc16(msg)
        if crc_result != chksum:
            logerr('CRC result is 0x%04x, should be 0x%04x' %
                          (crc_result, chksum))
            raise ValueError("CRC error")

    def __enter__(self):
        self.open()
        return self

    def __exit__(self, _, value, traceback):
        self.close()

    def open(self):
        dbg_serial(1, "open serial port %s" % self.port)
        self.serial_port = serial.Serial(self.port, self.baudrate,
                                         timeout=self.timeout)

    def close(self):
        if self.serial_port is not None:
            dbg_serial(1, "close serial port %s" % self.port)
            self.serial_port.close()
            self.serial_port = None

    def get_readings(self):
        buf = self.serial_port.readline().decode('utf-8')
        if len(buf) > 0:
            dbg_serial(2, "station said: %s" %
                       ' '.join(["%0.2X" % ord(c) for c in buf]))
        return buf.strip()

    def get_readings_with_retry(self, max_tries=5, retry_wait=10):
        for ntries in range(0, max_tries):
            try:
                return self.get_readings()
            except serial.serialutil.SerialException as e:
                loginf("Failed attempt %d of %d to get readings: %s" %
                       (ntries + 1, max_tries, e))
                time.sleep(retry_wait)
        else:
            msg = "Max retries (%d) exceeded for readings" % max_tries
            logerr(msg)
            raise Exception(msg)

    def reset(self, max_wait=30):
        """Reset the device, leaving it in a state that we can talk to it."""
        loginf("establish communication with the meteostick")

        # flush any previous data in the input buffer
        self.serial_port.flushInput()

        # Send a reset command
        self.serial_port.write(b'r\n')
        # Wait until we see the ? character
        start_ts = time.time()
        ready = False
        response = ''
        while not ready:
            time.sleep(0.1)
            while self.serial_port.inWaiting() > 0:
                c = self.serial_port.read(1).decode('utf-8')
                if c == '?':
                    ready = True
                elif c in string.printable:
                    response += c
            if time.time() - start_ts > max_wait:
                raise Exception("No 'ready' response from meteostick after %s seconds" % max_wait)
        loginf("reset: %s" % response.split('\n')[0])
        dbg_serial(2, "full response to reset: %s" % response)
        # Discard any serial input from the device
        time.sleep(0.2)
        self.serial_port.flushInput()
        return response

    def configure(self):
        """Configure the device to send data continuously."""
        loginf("configure meteostick to logger mode")

        # Show default settings (they might change with a new firmware version)
        self.send_command('?')

        # Set RF threshold
        self.send_command('x' + str(self.rf_threshold))

        # Listen to configured transmitters
        self.send_command('t' + str(self.transmitters))

        # Filter transmissions from anything other than configured transmitters
        self.send_command('f1')

        # Listen to configured repeaters
        self.send_command('r1')     # repeater 1  

        # Set device to produce 10-bytes raw data
        command = 'o3'
        self.send_command(command)

        # Set the frequency. Valid frequencies are US, EU and AU
        command = 'm0' # default to US
        if self.frequency == 'AU':
            command = 'm2'
        elif self.frequency == 'EU':
            command = 'm1'
        self.send_command(command)

        # From now on the device will produce lines with received data

    def send_command(self, cmd):
        cmd2 = (cmd + "\r").encode('utf-8')
        self.serial_port.write(cmd2)
        time.sleep(0.2)
        response = self.serial_port.read(self.serial_port.inWaiting()).decode('utf-8')
        dbg_serial(1, "cmd: '%s': %s" % (cmd, response))
        self.serial_port.flushInput()

    @staticmethod
    def get_parts(raw):
        raw_str = str(raw)
        dbg_parse(1, "readings: %s" % raw_str)
        parts = raw.split(' ')
        dbg_parse(3, "parts: %s (%s)" % (parts, len(parts)))
        if len(parts) < 2:
            raise ValueError("not enough parts in '%s'" % raw)
        return parts

    def parse_readings(self, raw, rain_per_tip):
        data = dict()
        if not raw:
            return data
        if not all(c in string.printable for c in raw):
            logerr("unprintable characters in readings: %s" % _fmt(raw))
            return data
        try:
            data = self.parse_raw(raw,
                                  self.channels['iss'],
                                  self.channels['anemometer'],
                                  self.channels['leaf_soil'],
                                  self.channels['temp_hum_1'],
                                  self.channels['temp_hum_2'],
                                  rain_per_tip)
        except ValueError as e:
            logerr("parse failed for '%s': %s" % (raw, e))
        return data

    @staticmethod
    def parse_raw(raw, iss_ch, wind_ch, ls_ch, th1_ch, th2_ch, rain_per_tip):
        data = dict()
        parts = Meteostick.get_parts(raw)
        n = len(parts)
        if parts[0] == 'B':
            # message example:
            # B 29530 338141 366 101094 60 37
            data['channel'] = Meteostick.RAW_CHANNEL # rf_signal data will not be used
            data['rf_signal'] = 0  # not available
            data['rf_missed'] = 0  # not available
            if n >= 6:
                data['temp_in'] = float(parts[3]) / 10.0 # C
                data['pressure'] = float(parts[4]) / 100.0 # hPa
                if n > 7:
                    # only with custom receiver
                    data['humidity_in'] = float(parts[7])
            else:
                logerr("B: not enough parts (%s) in '%s'" % (n, raw))
        elif parts[0] == 'I':
            # ...existing code...
            raw_msg = [0] * 10
            for i in range(0, 10):
                raw_msg[i] = parts[i + 2]
            pkt = bytearray([int(i, base=16) for i in raw_msg])

            # perform crc-check
            raw_msg_crc = [0] * 8
            if pkt[8] == 0xFF and pkt[9] == 0xFF:
                # message received from davis equipment
                # Calculate crc with bytes 0-7, result must be equal to 0
                chksum = 0
                for i in range(0, 8):
                    raw_msg_crc[i] = chr(int(parts[i + 2], 16))
                Meteostick._check_crc(raw_msg_crc, chksum)
            else:
                # message received via repeater
                # Calculate crc with bytes 0-5 and 8-9, result must be equal
                # to bytes 6-7
                chksum = (pkt[6] << 8) + pkt[7]
                for i in range(0, 6):
                    raw_msg_crc[i] = chr(int(parts[i + 2], 16))
                for i in range(6, 8):
                    raw_msg_crc[i] = chr(int(parts[i + 4], 16))
                Meteostick._check_crc(raw_msg_crc, chksum)

            data['channel'] = (pkt[0] & 0x7) + 1
            battery_low = (pkt[0] >> 3) & 0x1
            data['rf_signal'] = int(parts[13])
            time_since_last = int(parts[14])
            # the cyclus time varies from 2.5 to 3 seconds for channels 1 to 8
            # simplifiy calculation with max cyclus time of 3.0 seconds
            data['rf_missed'] = (time_since_last // 2500000) - 1
            if data['rf_missed'] > 0:
                dbg_parse(3, "channel %s missed %s" %
                          (data['channel'], data['rf_missed']))

            if data['channel'] == iss_ch or data['channel'] == wind_ch \
                    or data['channel'] == th1_ch or data['channel'] == th2_ch:
                if data['channel'] == iss_ch:
                    data['bat_iss'] = battery_low
                elif data['channel'] == wind_ch:
                    data['bat_anemometer'] = battery_low
                elif data['channel'] == th1_ch:
                    data['bat_th_1'] = battery_low
                else:
                    data['bat_th_2'] = battery_low

                # Wind data processing
                wind_speed_raw = pkt[1]
                wind_dir_raw = pkt[2]
                if not(wind_speed_raw == 0 and wind_dir_raw == 0):
                    dbg_parse(3, "wind_speed_raw=%03x wind_dir_raw=0x%03x" %
                              (wind_speed_raw, wind_dir_raw))

                    # Vantage Pro and Pro2
                    if wind_dir_raw == 0:
                        wind_dir_pro = 5.0
                    elif wind_dir_raw == 255:
                        wind_dir_pro = 355.0
                    else:
                        wind_dir_pro = 9.0 + (wind_dir_raw - 1) * 342.0 / 253.0

                    # Vantage Vue
                    wind_dir_vue = wind_dir_raw * 1.40625 + 0.3

                    data['wind_speed_raw'] = wind_speed_raw
                    data['wind_dir'] = wind_dir_pro
                    data['wind_speed'] = wind_speed_raw * MPH_TO_MPS
                    dbg_parse(3, "WS=%s WD=%s WS_raw=%s WD_raw=%s WD_pro=%s WD_vue=%s" %
                              (data['wind_speed'], data['wind_dir'],
                               wind_speed_raw,
                               wind_dir_raw if wind_dir_raw <= 180 else 360 - wind_dir_raw,
                               wind_dir_pro, wind_dir_vue))

                # data from both iss sensors and extra sensors on
                # Anemometer Transport Kit
                message_type = (pkt[0] >> 4 & 0xF)
                
                # Process different message types (simplified for reader)
                if message_type == 8:
                    # outside temperature
                    temp_raw = (pkt[3] << 4) + (pkt[4] >> 4)  # 12-bits temp value
                    if temp_raw != 0xFFC and temp_raw != 0xFF8:
                        if pkt[4] & 0x8:
                            # digital temp sensor - value is twos-complement
                            if pkt[3] & 0x80 != 0:
                                temp_f = -(temp_raw ^ 0xFFF) / 10.0
                            else:
                                temp_f = temp_raw / 10.0
                            temp_c = FtoC(temp_f)
                            dbg_parse(3, "digital temp_raw=0x%03x temp_f=%s temp_c=%s"
                                      % (temp_raw, temp_f, temp_c))
                        else:
                            # analog sensor (thermistor)
                            temp_raw = temp_raw // 4  # 10-bits temp value
                            temp_c = calculate_thermistor_temp(temp_raw)
                            dbg_parse(3, "thermistor temp_raw=0x%03x temp_c=%s"
                                      % (temp_raw, temp_c))
                        if data['channel'] == th1_ch:
                            data['temp_1'] = temp_c
                        elif data['channel'] == th2_ch:
                            data['temp_2'] = temp_c
                        elif data['channel'] == wind_ch:
                            data['temp_3'] = temp_c
                        else:
                            data['temperature'] = temp_c
                elif message_type == 0xA:
                    # outside humidity
                    humidity_raw = ((pkt[4] >> 4) << 8) + pkt[3]
                    if humidity_raw != 0:
                        if pkt[4] & 0x08 == 0x8:
                            # digital sensor
                            humidity = humidity_raw / 10.0
                        else:
                            # analog sensor (pkt[4] & 0x0f == 0x5)
                            humidity = humidity_raw * -0.301 + 710.23
                        if data['channel'] == th1_ch:
                            data['humid_1'] = humidity
                        elif data['channel'] == th2_ch:
                            data['humid_2'] = humidity
                        elif data['channel'] == wind_ch:
                            loginf("Warning: humidity sensor of Anemometer Transmitter Kit not in sensor map: %s" % humidity)
                        else:
                            data['humidity'] = humidity
                        dbg_parse(3, "humidity_raw=0x%03x value=%s" %
                                  (humidity_raw, humidity))
                elif message_type == 0xE:
                    # rain
                    rain_count_raw = pkt[3]
                    if rain_count_raw != 0x80:
                        rain_count = rain_count_raw & 0x7F  # skip high bit
                        data['rain_count'] = rain_count
                        dbg_parse(3, "rain_count_raw=0x%02x value=%s" %
                                  (rain_count_raw, rain_count))

        elif parts[0] == '#':
            loginf("%s" % raw)
        else:
            logerr("unknown sensor identifier '%s' in %s" % (parts[0], raw))
        return data

def send_to_influxdb(client, measurement, data, channel=None):
    """Send data to InfluxDB"""
    if not client:
        return
    
    try:
        # Prepare the data point
        fields = {}
        tags = {}
        
        # Add channel as tag if available
        if channel is not None:
            tags['channel'] = str(channel)
        
        # Convert data to appropriate fields
        for key, value in data.items():
            if key in ['channel', 'rf_signal', 'rf_missed']:
                continue  # Skip these as they're handled separately or not needed
            
            # Convert to float if possible, otherwise keep as string
            try:
                fields[key] = float(value)
            except (ValueError, TypeError):
                fields[key] = str(value)
        
        if not fields:
            return  # No data to send
        
        # Add RF signal info if available
        if 'rf_signal' in data:
            fields['rf_signal'] = int(data['rf_signal'])
        if 'rf_missed' in data:
            fields['rf_missed'] = int(data['rf_missed'])
        
        json_body = [
            {
                "measurement": measurement,
                "tags": tags,
                "time": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
                "fields": fields
            }
        ]
        
        client.write_points(json_body)
        logdbg(f"Sent to InfluxDB: {len(fields)} fields")
        
    except Exception as e:
        logerr(f"Failed to send data to InfluxDB: {e}")

def main():
    usage = """%prog [options] [--help]
    
Read and display messages from a Meteostick device."""

    # Debug: Print environment variables
    print("Environment Variables:")
    for key in os.environ:
        if key.startswith('METEOSTICK_'):
            print(f"  {key}={os.environ[key]}")
    print()

    parser = optparse.OptionParser(usage=usage)
    parser.add_option('--port', dest='port', metavar='PORT',
                      help='serial port to which the meteostick is connected',
                      default=os.getenv('METEOSTICK_PORT', Meteostick.DEFAULT_PORT))
    parser.add_option('--baud', dest='baud', metavar='BAUDRATE', type=int,
                      help='serial port baud rate',
                      default=int(os.getenv('METEOSTICK_BAUDRATE', Meteostick.DEFAULT_BAUDRATE)))
    parser.add_option('--freq', dest='freq', metavar='FREQUENCY',
                      help='comm frequency: US (915MHz), EU (868MHz), or AU (915MHz)',
                      default=os.getenv('METEOSTICK_FREQUENCY', Meteostick.DEFAULT_FREQUENCY))
    parser.add_option('--rfs', dest='rfs', metavar='RF_SENSITIVITY', type=int,
                      help='RF sensitivity (0-125, default 90)',
                      default=int(os.getenv('METEOSTICK_RF_SENSITIVITY', Meteostick.DEFAULT_RF_SENSITIVITY)))
    parser.add_option('--iss-channel', dest='c_iss', metavar='ISS_CHANNEL', type=int,
                      help='channel for ISS (1-8)', default=int(os.getenv('METEOSTICK_ISS_CHANNEL', '1')))
    parser.add_option('--anemometer-channel', dest='c_anem', metavar='ANEM_CHANNEL', type=int,
                      help='channel for anemometer (0=none, 1-8)', default=int(os.getenv('METEOSTICK_ANEMOMETER_CHANNEL', '0')))
    parser.add_option('--leaf-soil-channel', dest='c_ls', metavar='LS_CHANNEL', type=int,
                      help='channel for leaf-soil station (0=none, 1-8)', default=int(os.getenv('METEOSTICK_LEAF_SOIL_CHANNEL', '0')))
    parser.add_option('--th1-channel', dest='c_th1', metavar='TH1_CHANNEL', type=int,
                      help='channel for T/H sensor 1 (0=none, 1-8)', default=int(os.getenv('METEOSTICK_TH1_CHANNEL', '0')))
    parser.add_option('--th2-channel', dest='c_th2', metavar='TH2_CHANNEL', type=int,
                      help='channel for T/H sensor 2 (0=none, 1-8)', default=int(os.getenv('METEOSTICK_TH2_CHANNEL', '0')))
    parser.add_option('--rain-bucket', dest='bucket', metavar='BUCKET_TYPE', type=int,
                      help='rain bucket type: 0=0.01in, 1=0.2mm (default 1)', default=int(os.getenv('METEOSTICK_RAIN_BUCKET', '1')))
    
    # InfluxDB options
    parser.add_option('--influxdb-host', dest='influx_host', metavar='HOST',
                      help='InfluxDB host (default: localhost)', default=os.getenv('METEOSTICK_INFLUXDB_HOST', 'localhost'))
    parser.add_option('--influxdb-port', dest='influx_port', metavar='PORT', type=int,
                      help='InfluxDB port (default: 8086)', default=int(os.getenv('METEOSTICK_INFLUXDB_PORT', '8086')))
    parser.add_option('--influxdb-user', dest='influx_user', metavar='USER',
                      help='InfluxDB username (deprecated, use --influxdb-token)', default=os.getenv('METEOSTICK_INFLUXDB_USER', ''))
    parser.add_option('--influxdb-pass', dest='influx_pass', metavar='PASSWORD',
                      help='InfluxDB password (deprecated, use --influxdb-token)', default=os.getenv('METEOSTICK_INFLUXDB_PASS', ''))
    parser.add_option('--influxdb-token', dest='influx_token', metavar='TOKEN',
                      help='InfluxDB authentication token', default=os.getenv('METEOSTICK_INFLUXDB_TOKEN', ''))
    parser.add_option('--influxdb-db', dest='influx_db', metavar='DATABASE',
                      help='InfluxDB database name (default: weather)', default=os.getenv('METEOSTICK_INFLUXDB_DB', 'weather'))
    parser.add_option('--influxdb-measurement', dest='influx_measurement', metavar='MEASUREMENT',
                      help='InfluxDB measurement name (default: meteostick)', default=os.getenv('METEOSTICK_INFLUXDB_MEASUREMENT', 'meteostick'))
    parser.add_option('--enable-influxdb', dest='enable_influx', action='store_true',
                      help='Enable sending data to InfluxDB', default=os.getenv('METEOSTICK_ENABLE_INFLUXDB', 'false').lower() in ('true', '1', 'yes', 'on'))

    (opts, args) = parser.parse_args()

    print("Meteostick Reader")
    print("================")
    print(f"Port: {opts.port}")
    print(f"Baudrate: {opts.baud}")
    print(f"Frequency: {opts.freq}")
    print(f"RF Sensitivity: {opts.rfs}")
    print(f"ISS Channel: {opts.c_iss}")
    print(f"Anemometer Channel: {opts.c_anem}")
    print(f"Leaf/Soil Channel: {opts.c_ls}")
    print(f"T/H 1 Channel: {opts.c_th1}")
    print(f"T/H 2 Channel: {opts.c_th2}")
    print(f"Rain bucket type: {opts.bucket}")
    
    # InfluxDB setup
    influx_client = None
    if opts.enable_influx:
        if not INFLUXDB_AVAILABLE:
            print("ERROR: InfluxDB client not available. Install with: pip install influxdb")
            return 1
        
        print(f"InfluxDB Host: {opts.influx_host}:{opts.influx_port}")
        print(f"InfluxDB Database: {opts.influx_db}")
        print(f"InfluxDB Measurement: {opts.influx_measurement}")
        
        # Determine authentication method
        if opts.influx_token:
            print("Using token-based authentication")
            auth_method = "token"
        elif opts.influx_user or opts.influx_pass:
            print("Using username/password authentication (deprecated)")
            auth_method = "userpass"
        else:
            print("Using no authentication")
            auth_method = "none"
        
        try:
            # Create client based on authentication method
            if auth_method == "token":
                # For token-based auth with influxdb library, pass token as password
                influx_client = InfluxDBClient(
                    host=opts.influx_host,
                    port=opts.influx_port,
                    username='token',  # Use 'token' as username
                    password=opts.influx_token,  # Use token as password
                    database=opts.influx_db,
                    ssl=False,  # Set to True if using HTTPS
                    verify_ssl=False
                )
            elif auth_method == "userpass":
                influx_client = InfluxDBClient(
                    host=opts.influx_host,
                    port=opts.influx_port,
                    username=opts.influx_user if opts.influx_user else None,
                    password=opts.influx_pass if opts.influx_pass else None,
                    database=opts.influx_db
                )
            else:
                influx_client = InfluxDBClient(
                    host=opts.influx_host,
                    port=opts.influx_port,
                    database=opts.influx_db
                )
            
            # Test connection
            influx_client.ping()
            
            # Create database if it doesn't exist
            databases = influx_client.get_list_database()
            if not any(db['name'] == opts.influx_db for db in databases):
                influx_client.create_database(opts.influx_db)
                print(f"Created InfluxDB database: {opts.influx_db}")
            
            print("InfluxDB connection established")
            
        except Exception as e:
            print(f"Failed to connect to InfluxDB: {e}")
            print("Continuing without InfluxDB support...")
            influx_client = None
    else:
        print("InfluxDB support disabled")
    
    print()

    # Calculate rain per tip based on bucket type
    rain_per_tip = 0.254 if opts.bucket == 0 else 0.2  # mm

    try:
        # Create and configure the Meteostick
        station = Meteostick(
            port=opts.port,
            baudrate=opts.baud,
            transceiver_frequency=opts.freq,
            rf_sensitivity=opts.rfs,
            iss_channel=opts.c_iss,
            anemometer_channel=opts.c_anem,
            leaf_soil_channel=opts.c_ls,
            temp_hum_1_channel=opts.c_th1,
            temp_hum_2_channel=opts.c_th2
        )

        print("Opening connection...")
        station.open()
        
        print("Resetting device...")
        reset_info = station.reset()
        print(f"Reset response: {reset_info.strip()}")
        
        print("Configuring device...")
        station.configure()
        
        print(f"\nListening for messages (Press Ctrl+C to exit)...")
        if influx_client:
            print(f"Data will be sent to InfluxDB: {opts.influx_host}:{opts.influx_port}/{opts.influx_db}")
        print("=" * 60)
        
        message_count = 0
        influx_sent_count = 0
        
        while True:
            try:
                # Get raw reading
                raw_reading = station.get_readings()
                
                if raw_reading:
                    message_count += 1
                    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
                    print(f"[{timestamp}] Message #{message_count}: {raw_reading}")
                    
                    # Parse the reading for additional info
                    try:
                        parsed_data = station.parse_readings(raw_reading, rain_per_tip)
                        if parsed_data:
                            print(f"  Parsed data: {parsed_data}")
                            
                            # Send to InfluxDB if enabled and we have meaningful data
                            if influx_client and len(parsed_data) > 2:  # More than just channel and rf_signal
                                channel = parsed_data.get('channel')
                                send_to_influxdb(influx_client, opts.influx_measurement, parsed_data, channel)
                                influx_sent_count += 1
                                
                    except Exception as e:
                        print(f"  Parse error: {e}")
                    
                    print()
                else:
                    # No data received, small delay
                    time.sleep(0.1)
                    
            except KeyboardInterrupt:
                print("\nShutting down...")
                break
            except Exception as e:
                print(f"Error reading data: {e}")
                time.sleep(1)
        
    except Exception as e:
        print(f"Error: {e}")
        return 1
    
    finally:
        try:
            station.close()
            print("Connection closed.")
        except:
            pass
    
    print(f"Total messages received: {message_count}")
    if influx_client:
        print(f"Total messages sent to InfluxDB: {influx_sent_count}")
    return 0

if __name__ == '__main__':
    sys.exit(main())
if __name__ == '__main__':
    sys.exit(main())