Program.cs

/*
SMS Gateway application that uses Redis pub/sub to send and receive SMS messages using AT commands.
Copyright(C) 2024 - Emre Cebeci

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

using System.IO.Ports;
using System.Text.Json;
using Microsoft.Extensions.Logging;
using StackExchange.Redis;

namespace Sms_Gateway;

public static class Program {
  private static SerialPort? _serialPort;
  private static ISubscriber? _pubsub;
  private static RedisChannel _receivedChannel;
  
  private static readonly ILogger Logger =
    LoggerFactory.Create(builder => builder.AddConsole())
      .CreateLogger("Sms_Gateway");
  
  public static void Main() {
    EnvReader.Load(".env");
    InitializeSerialPort();
    InitializeRedis();
    
    Console.WriteLine("Type QUIT to exit");
    var stringComparer = StringComparer.OrdinalIgnoreCase;
    while (true) {
      var message = Console.ReadLine() ?? string.Empty;
      
      if (stringComparer.Equals("quit", message)) break;
      
      Logger.LogInformation("PC: {Message}", message);
      _serialPort?.WriteLine(
        string.Format($"{message}\r\n"));
    }
    
    Logger.LogInformation("Closing Serial port");
    _serialPort?.Close();
  }
  
  private static void InitializeSerialPort() {
    _serialPort =
      new SerialPort {
        PortName = Environment.GetEnvironmentVariable("MODEM_PORTNAME"),
        BaudRate = 9600,
        Parity = Parity.None,
        DataBits = 8,
        StopBits = StopBits.One,
        Handshake = Handshake.None,
        ReadTimeout = Timeout.Infinite,
        WriteTimeout = 500
      };
    
    Logger.LogInformation("Open Serial port and configuring modem");
    try {
      _serialPort.Open();
    }
    catch (Exception ex) {
      Logger.LogCritical(ex, "Error opening serial port: {Message}", ex.Message);
      
      return;
    }
    
    _serialPort.WriteLine("AT+CPMS=\"ME\"\r\n");
    _serialPort.WriteLine("AT+CMGF=1\r\n");
    _serialPort.WriteLine("AT+CSMP=17,167,0,0\r\n");
    Logger.LogInformation("Add data received event handler");
    _serialPort.DataReceived += SerialPortDataReceived;
  }
  
  private static void SerialPortDataReceived(object sender, SerialDataReceivedEventArgs e) {
    var message = _serialPort?.ReadExisting() ?? string.Empty;
    if (message.Contains("+CMTI: \"ME\"")) {
      Logger.LogInformation("New message received. Reading all messages...");
      _serialPort?.WriteLine("AT+CMGL=\"ALL\"\r\n");
      
      return;
    }
    
    if (message.Contains("+CMGL:")) {
      Logger.LogInformation("Remove unread messages");
      _serialPort?.WriteLine("AT+CMGD=,2\r\n");
      Logger.LogInformation("Handling message");
      HandleReceivedMessage(message);
      
      return;
    }
    
    Logger.LogInformation("Modem: {Message}", message.Trim());
  }
  
  private static void HandleReceivedMessage(string messageText) {
    ParseReceivedMessage(messageText, out var messages);
    messages.ForEach(m => _pubsub?.Publish(_receivedChannel, (RedisValue)m));
  }
  
  private static void ParseReceivedMessage(string message, out List<SmsMessage> output) {
    output = [];
    try {
      var indexStart = message.IndexOf(':') + 2;
      do {
        var indexEnd = message.IndexOf(',', indexStart);
        var index = message[indexStart..indexEnd];
        
        var statusStart = message.IndexOf('"', indexEnd) + 1;
        var statusEnd = message.IndexOf('"', statusStart);
        var status = message[statusStart..statusEnd];
        
        var senderStart = message.IndexOf("\",\"", statusStart, StringComparison.Ordinal) + 3;
        var senderEnd = message.IndexOf('\"', senderStart);
        var sender = message[senderStart..senderEnd];
        
        var unknownValStart = senderEnd + 2;
        var unknownValEnd = message.IndexOf(',', unknownValStart);
        var unknownVal = message[unknownValStart..unknownValEnd];
        
        var dateTimeStart = message.IndexOf('"', unknownValEnd) + 1;
        var dateTimeEnd = message.IndexOf('"', dateTimeStart);
        var dateTime = message[dateTimeStart..dateTimeEnd];
        
        var contentStart = message.IndexOf('\n', dateTimeEnd) + 1;
        var contentEnd = message.IndexOf('\r', contentStart);
        var content = message[contentStart..contentEnd];
        
        Logger.LogInformation(
          "READING Index: {Index}, Sender: {Sender}, Unknown Value: {UnknownVal}, DateTime: {DateTime}, Content: {Content}",
          index, sender, unknownVal, dateTime, content);
        if (status != "REC UNREAD") {
          indexStart = message.IndexOf(':', contentEnd) + 2;
          Logger.LogWarning("Message is not unread. It has already been read. Skipping...");
          
          continue;
        }
        
        output.Add(new SmsMessage(content, DateTime.Now, sender));
        indexStart = message.IndexOf(':', contentEnd) + 2;
      } while (indexStart > 2);
    }
    catch (Exception ex) {
      Logger.LogError(ex, "Error parsing message: {Message}", ex.Message);
    }
  }
  
  private static void SendMessage(SmsMessage message) {
    try {
      if (message.Receiver == null) {
        Logger.LogError("Receiver is null");
        
        return;
      }
      
      _serialPort?.WriteLine($"AT+CMGS=\"{message.Receiver}\"\r");
      _serialPort?.WriteLine($"{message.Content}\x1A");
      Logger.LogInformation("Message sent to {Receiver}: {Message}", message.Receiver, message);
    }
    catch (Exception ex) {
      Logger.LogError(ex, "Error sending message: {Message}", ex.Message);
    }
  }
  
  private static void InitializeRedis() {
    var redisConnectionString =
      Environment.GetEnvironmentVariable("REDIS_CONNECTION_STRING") ??
      throw new ArgumentNullException(null,
        "The environment variable REDIS_CONNECTION_STRING is not set.");
    
    var receivedChannelName =
      Environment.GetEnvironmentVariable("REDIS_CHANNEL_RECEIVED") ??
      throw new ArgumentNullException(null,
        "The environment variable REDIS_CHANNEL_RECEIVED is not set.");
    
    var sendChannelName =
      Environment.GetEnvironmentVariable("REDIS_CHANNEL_SEND") ??
      throw new ArgumentNullException(null,
        "The environment variable REDIS_CHANNEL_SEND is not set.");
    
    Logger.LogInformation(
      "Connecting to Redis: {ConnectionString}, Subscribing to channels: {ReceivedChannel}, {SendChannel}",
      redisConnectionString, receivedChannelName, sendChannelName);
    
    var redis = ConnectionMultiplexer.Connect(redisConnectionString);
    
    _receivedChannel =
      new RedisChannel(Environment.GetEnvironmentVariable("REDIS_CHANNEL_RECEIVED") ??
                       throw new ArgumentNullException(null,
                         "The environment variable REDIS_CHANNEL_RECEIVED is not set."),
        RedisChannel.PatternMode.Literal);
    
    var sendChannel =
      new RedisChannel(
        Environment.GetEnvironmentVariable("REDIS_CHANNEL_SEND") ??
        throw new ArgumentNullException(null, "The environment variable REDIS_CHANNEL_SEND is not set."),
        RedisChannel.PatternMode.Literal);
    
    _pubsub = redis.GetSubscriber();
    _pubsub.Subscribe(sendChannel, static (channel, message) => {
      try {
        if (string.IsNullOrWhiteSpace(message.ToString())) return;
        var smsMessage = JsonSerializer.Deserialize<SmsMessage>(message.ToString());
        
        if (smsMessage == null) return;
        
        SendMessage(smsMessage);
      }
      catch (JsonException ex) {
        Logger.LogError(ex, "Error deserializing message on channel {Channel}", channel);
      }
      catch (Exception ex) {
        Logger.LogError(ex, "Unexpected error processing message on channel {Channel}: {Message}", channel,
          ex.Message);
      }
    });
  }
}