diff --git a/.gitignore b/.gitignore
index f2fe2a5..16817f6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 # Exclude build files
 dist/
+data/
 vendor/
-.env
+.env
\ No newline at end of file
diff --git a/Makefile b/Makefile
index bb52141..50239c3 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
 build:
-	go build -o dist/rubrion-cli ./cmd/rubrion-cli/main.go
+	go build -o dist/enemeter-data-processing ./cmd/enemeter-data-processing/main.go
 
 .PHONY: build
diff --git a/README.md b/README.md
index 36c23da..18be7f9 100644
--- a/README.md
+++ b/README.md
@@ -1,22 +1,234 @@
-# Rubrion CLI Template
+# ENEMETER Data Processing Tool
 
-This repository is a template for building Go CLI tools for Rubrion.
+A powerful command-line tool for efficiently processing and analyzing ENEMETER energy measurement data.
 
-## Getting Started
+## Overview
 
-To run the CLI locally:
-\`\`\`
-go run ./cmd/rubrion-cli/main.go
-\`\`\`
+This tool processes data from ENEMETER devices, which measure various electrical parameters such as voltage, current, and temperature. The tool is designed to handle large CSV files efficiently and provide meaningful energy metrics for analysis.
 
-## Build
+## Features
 
-You can build the CLI using:
-\`\`\`
-make build
-\`\`\`
+- Process large CSV files efficiently with streaming mode
+- Filter data by time range, temperature, voltage, or current
+- Sample data to reduce processing requirements
+- Extract specific metrics for targeted analysis
+- Export results in multiple formats (text, JSON, CSV)
+- Calculate energy consumption metrics and statistics
+- Analyze battery charging/discharging patterns
+- Evaluate solar panel contribution
 
-## Release Process
+## Installation
 
-This template includes GitHub Actions workflows for QA checks and production releases.
-Refer to the files under \`.github/workflows/\` for details.
+### Prerequisites
+
+- Go 1.23 or later
+
+### Building from source
+
+```bash
+git clone https://github.com/yourusername/enemeter-data-processing.git
+cd enemeter-data-processing
+go build
+```
+
+## Data Format
+
+ENEMETER data is provided in CSV format with four columns:
+
+1. **Time Delta (milliseconds)** - Time elapsed since the last measurement
+2. **Temperature (millicelsius)** - System temperature
+3. **Voltage (microvolts)** - Battery voltage
+4. **Current (nanoamperes)** - System current (positive when charging, negative when discharging)
+
+Example:
+```
+0000052051,0004815430,-1275169536,0000023192
+0000000047,0004815430,-1275169536,0000023192
+0000000047,0004815790,-1276443264,0000023192
+```
+
+## Basic Usage
+
+Process a CSV file with default settings:
+
+```bash
+./enemeter-data-processing --input=data/data.csv
+```
+
+Save results to a text file:
+
+```bash
+./enemeter-data-processing --input=data/data.csv --output=report.txt
+```
+
+## Command-line Options
+
+### Input/Output Options
+
+- `--input=<path>`: Path to the input CSV file (required)
+- `--output=<path>`: Path to save the output report (optional)
+- `--format=<text|json|csv>`: Output format (default: text)
+
+### Processing Options
+
+- `--stream`: Use memory-efficient streaming mode for large files
+- `--sample=<N>`: Process every Nth record (default: 1, process all records)
+- `--max=<N>`: Maximum number of records to process (default: 0, no limit)
+
+### Time Filtering Options
+
+- `--start=<time>`: Start time for filtering (format: YYYY-MM-DD[THH:MM:SS])
+- `--end=<time>`: End time for filtering (format: YYYY-MM-DD[THH:MM:SS])
+- `--window=<duration>`: Time window to process (e.g., 1h, 30m, 24h)
+
+### Data Filtering Options
+
+- `--min-temp=<value>`: Minimum temperature threshold in millicelsius
+- `--volt-min=<value>`: Minimum voltage threshold in microvolts
+- `--volt-max=<value>`: Maximum voltage threshold in microvolts
+- `--curr-min=<value>`: Minimum current threshold in nanoamperes
+- `--curr-max=<value>`: Maximum current threshold in nanoamperes
+
+### Metric Extraction
+
+- `--metric=<name>`: Extract a specific metric (see below)
+
+## Available Metrics
+
+- `total_energy`: Total energy consumption in joules
+- `average_power`: Average power in watts
+- `peak_power`: Peak power in watts
+- `temperature`: Temperature statistics
+- `energy_by_hour`: Energy consumption by hour
+- `voltage_stats`: Voltage statistics
+- `current_stats`: Current statistics
+- `battery_discharge`: Battery discharge statistics
+- `solar_contribution`: Solar panel contribution
+
+## Examples
+
+### Basic Processing
+
+Process a CSV file and display all metrics:
+
+```bash
+./enemeter-data-processing --input=data/data.csv
+```
+
+### Memory-Efficient Processing for Large Files
+
+Use streaming mode with sampling for very large files:
+
+```bash
+./enemeter-data-processing --input=big-data.csv --stream --sample=10
+```
+
+This processes only every 10th record, reducing memory requirements.
+
+### Filtering by Time
+
+Process data from a specific time range:
+
+```bash
+./enemeter-data-processing --input=data.csv --start="2025-04-01" --end="2025-04-02"
+```
+
+Process the last 24 hours of data:
+
+```bash
+./enemeter-data-processing --input=data.csv --window=24h
+```
+
+### Extracting Specific Metrics
+
+Get only temperature statistics in JSON format:
+
+```bash
+./enemeter-data-processing --input=data.csv --metric=temperature --format=json
+```
+
+Extract hourly energy consumption in CSV format:
+
+```bash
+./enemeter-data-processing --input=data.csv --metric=energy_by_hour --format=csv
+```
+
+### Filtering by Data Values
+
+Process only records with voltage between specified values:
+
+```bash
+./enemeter-data-processing --input=data.csv --volt-min=3500000 --volt-max=4200000
+```
+
+Process only records where temperature is above a certain threshold:
+
+```bash
+./enemeter-data-processing --input=data.csv --min-temp=25000
+```
+
+## Output Examples
+
+### Text Output (Default)
+
+```
+========== ENEMETER DATA PROCESSING REPORT ==========
+Input File: data.csv
+Date: 2025-04-09 10:15:32
+Data Points: 1253
+Time Range: 2025-04-08 08:30:15 to 2025-04-09 08:30:10
+
+ENERGY METRICS
+-------------
+Total Energy Consumed: 156.4578 joules
+Average Power: 0.0548 watts
+Peak Power: 0.1245 watts
+Estimated Energy per Day: 157.9825 joules
+Measurement Duration: 86395.00 seconds
+
+TEMPERATURE STATISTICS
+---------------------
+Minimum Temperature: 22.45 °C
+Maximum Temperature: 28.95 °C
+Average Temperature: 24.75 °C
+
+... additional sections ...
+```
+
+### JSON Output
+
+```json
+{
+  "TotalJoules": 156.4578,
+  "AveragePowerWatts": 0.0548,
+  "PeakPowerWatts": 0.1245,
+  "JoulesPerDay": 157.9825,
+  "DurationSeconds": 86395.0,
+  "TemperatureStats": {
+    "MinTempCelsius": 22.45,
+    "MaxTempCelsius": 28.95,
+    "AvgTempCelsius": 24.75
+  },
+  ...
+}
+```
+
+### CSV Output
+
+```
+Metric,Value
+TotalJoules,156.457800
+AveragePowerWatts,0.054800
+PeakPowerWatts,0.124500
+JoulesPerDay,157.982500
+DurationSeconds,86395.00
+...
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
\ No newline at end of file
diff --git a/cmd/enemeter-data-processing/main.go b/cmd/enemeter-data-processing/main.go
new file mode 100644
index 0000000..9cc022b
--- /dev/null
+++ b/cmd/enemeter-data-processing/main.go
@@ -0,0 +1,60 @@
+package main
+
+import (
+	"enemeter-data-processing/internal/commands"
+	"fmt"
+	"os"
+)
+
+func main() {
+	// Display version and app name
+	fmt.Printf("%s version: %s\n", commands.AppName, commands.CurrentVersion)
+
+	if len(os.Args) < 2 {
+		printUsage()
+		os.Exit(1)
+	}
+
+	// Check the command
+	switch os.Args[1] {
+	case "process":
+		// Create and configure the process command
+		processCmd := commands.SetupProcessCommand()
+		if err := processCmd.Parse(os.Args[2:]); err != nil {
+			fmt.Fprintf(os.Stderr, "Error parsing arguments: %v\n", err)
+			processCmd.Usage()
+			os.Exit(1)
+		}
+
+		// Parse CLI options and execute the process command
+		options := commands.ParseCommandLineOptions(processCmd)
+		if err := commands.ProcessCommand(options); err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			os.Exit(1)
+		}
+
+	case "version":
+		fmt.Printf("%s\n", commands.CurrentVersion)
+
+	case "help":
+		printUsage()
+
+	default:
+		fmt.Fprintf(os.Stderr, "Unknown command: %s\n", os.Args[1])
+		printUsage()
+		os.Exit(1)
+	}
+}
+
+// printUsage displays help information for the CLI tool
+func printUsage() {
+	fmt.Printf("%s - A tool for processing and analyzing ENEMETER data\n\n", commands.AppName)
+	fmt.Println("Usage:")
+	fmt.Println("  enemeter-cli <command> [options]")
+	fmt.Println("\nAvailable Commands:")
+	fmt.Println("  process     Process ENEMETER data files")
+	fmt.Println("  version     Show version information")
+	fmt.Println("  help        Show help information")
+	fmt.Println("\nFor command-specific help:")
+	fmt.Println("  enemeter-cli <command> --help")
+}
diff --git a/cmd/rubrion-cli/main.go b/cmd/rubrion-cli/main.go
deleted file mode 100644
index ef57421..0000000
--- a/cmd/rubrion-cli/main.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"rubrion-cli/internal/commands"
-)
-
-func main() {
-	fmt.Printf("Rubrion CLI version: %s\n", commands.CurrentVersion)
-
-	if len(os.Args) > 1 {
-		fmt.Println("Received arguments:", os.Args[1:])
-	} else {
-		fmt.Println("Usage: rubrion-cli [command] [args]")
-	}
-}
diff --git a/go.mod b/go.mod
index ddb7853..75ebc80 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,3 @@
-module rubrion-cli
+module enemeter-data-processing
 
 go 1.23
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..e69de29
diff --git a/internal/commands/process.go b/internal/commands/process.go
new file mode 100644
index 0000000..7d79de8
--- /dev/null
+++ b/internal/commands/process.go
@@ -0,0 +1,698 @@
+package commands
+
+import (
+	"encoding/json"
+	"enemeter-data-processing/internal/metrics"
+	"enemeter-data-processing/internal/parser"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// OutputFormat determines how the CLI results should be displayed
+type OutputFormat string
+
+const (
+	FormatText OutputFormat = "text"
+	FormatJSON OutputFormat = "json"
+	FormatCSV  OutputFormat = "csv"
+)
+
+// CommandLineOptions holds all CLI options
+type CommandLineOptions struct {
+	// Input/output options
+	InputFile  string
+	OutputFile string
+	Format     OutputFormat
+
+	// Processing options
+	UseStreaming bool
+	SampleRate   int
+	MaxRecords   int
+
+	// Time filtering options
+	StartTime  string
+	EndTime    string
+	TimeWindow string // e.g. "1h", "30m", "24h"
+
+	// Data filtering options
+	MinTemp    int64
+	VoltageMin int64
+	VoltageMax int64
+	CurrentMin int64
+	CurrentMax int64
+
+	// Specific metrics to extract
+	Metric string
+}
+
+// SetupProcessCommand configures the process command with all its flags
+func SetupProcessCommand() *flag.FlagSet {
+	processCmd := flag.NewFlagSet("process", flag.ExitOnError)
+
+	// Input/output options
+	processCmd.String("input", "", "Path to the input CSV file")
+	processCmd.String("output", "", "Path to save the output report (optional)")
+	processCmd.String("format", "text", "Output format: text, json, or csv")
+
+	// Processing options
+	processCmd.Bool("stream", false, "Use streaming mode for processing large files")
+	processCmd.Int("sample", 1, "Process every Nth record (1 = all records)")
+	processCmd.Int("max", 0, "Maximum records to process (0 = no limit)")
+
+	// Time filtering options
+	processCmd.String("start", "", "Start time for filtering (format: YYYY-MM-DD[THH:MM:SS])")
+	processCmd.String("end", "", "End time for filtering (format: YYYY-MM-DD[THH:MM:SS])")
+	processCmd.String("window", "", "Time window to process (e.g., 1h, 30m, 24h)")
+
+	// Data filtering options
+	processCmd.Int64("min-temp", 0, "Minimum temperature threshold in millicelsius")
+	processCmd.Int64("volt-min", 0, "Minimum voltage threshold in microvolts")
+	processCmd.Int64("volt-max", 0, "Maximum voltage threshold in microvolts")
+	processCmd.Int64("curr-min", 0, "Minimum current threshold in nanoamperes")
+	processCmd.Int64("curr-max", 0, "Maximum current threshold in nanoamperes")
+
+	// Specific metrics extraction
+	processCmd.String("metric", "",
+		"Extract specific metric: total_energy, average_power, peak_power, temperature, "+
+			"energy_by_hour, voltage_stats, current_stats, battery_discharge, solar_contribution")
+
+	// Help function for the process command
+	processCmd.Usage = func() {
+		fmt.Println(AppName + " - Process and analyze ENEMETER data")
+		fmt.Println("\nUsage:")
+		fmt.Println("  enemeter-cli process [options]")
+		fmt.Println("\nExamples:")
+		fmt.Println("  # Basic usage")
+		fmt.Println("  enemeter-cli process --input=data/data.csv")
+		fmt.Println("\n  # Extract specific metrics")
+		fmt.Println("  enemeter-cli process --input=data.csv --metric=average_power")
+		fmt.Println("\n  # Filter by time window")
+		fmt.Println("  enemeter-cli process --input=data.csv --start=2025-04-01 --end=2025-04-02")
+		fmt.Println("\n  # Process large file efficiently")
+		fmt.Println("  enemeter-cli process --input=big-data.csv --stream --sample=10")
+		fmt.Println("\n  # Get temperature statistics in JSON format")
+		fmt.Println("  enemeter-cli process --input=data.csv --metric=temperature --format=json")
+		fmt.Println("\n  # Save output to a file")
+		fmt.Println("  enemeter-cli process --input=data.csv --output=report.txt")
+		fmt.Println("\nOptions:")
+		processCmd.PrintDefaults()
+	}
+
+	return processCmd
+}
+
+// ParseCommandLineOptions parses command line flags into a structured options object
+func ParseCommandLineOptions(cmd *flag.FlagSet) CommandLineOptions {
+	// Input/output options
+	inputFile := cmd.Lookup("input").Value.String()
+	outputFile := cmd.Lookup("output").Value.String()
+	format := cmd.Lookup("format").Value.String()
+
+	// Processing options
+	useStreaming := cmd.Lookup("stream").Value.(flag.Getter).Get().(bool)
+	sampleRate := int(cmd.Lookup("sample").Value.(flag.Getter).Get().(int64))
+	maxRecords := int(cmd.Lookup("max").Value.(flag.Getter).Get().(int64))
+
+	// Time filtering options
+	startTime := cmd.Lookup("start").Value.String()
+	endTime := cmd.Lookup("end").Value.String()
+	timeWindow := cmd.Lookup("window").Value.String()
+
+	// Data filtering options
+	minTemp := cmd.Lookup("min-temp").Value.(flag.Getter).Get().(int64)
+	voltageMin := cmd.Lookup("volt-min").Value.(flag.Getter).Get().(int64)
+	voltageMax := cmd.Lookup("volt-max").Value.(flag.Getter).Get().(int64)
+	currentMin := cmd.Lookup("curr-min").Value.(flag.Getter).Get().(int64)
+	currentMax := cmd.Lookup("curr-max").Value.(flag.Getter).Get().(int64)
+
+	// Specific metrics extraction
+	metric := cmd.Lookup("metric").Value.String()
+
+	// Convert format string to OutputFormat
+	var outputFormat OutputFormat
+	switch strings.ToLower(format) {
+	case "json":
+		outputFormat = FormatJSON
+	case "csv":
+		outputFormat = FormatCSV
+	default:
+		outputFormat = FormatText
+	}
+
+	return CommandLineOptions{
+		InputFile:    inputFile,
+		OutputFile:   outputFile,
+		Format:       outputFormat,
+		UseStreaming: useStreaming,
+		SampleRate:   sampleRate,
+		MaxRecords:   maxRecords,
+		StartTime:    startTime,
+		EndTime:      endTime,
+		TimeWindow:   timeWindow,
+		MinTemp:      minTemp,
+		VoltageMin:   voltageMin,
+		VoltageMax:   voltageMax,
+		CurrentMin:   currentMin,
+		CurrentMax:   currentMax,
+		Metric:       metric,
+	}
+}
+
+// ProcessCommand executes the main data processing functionality
+func ProcessCommand(options CommandLineOptions) error {
+	// Validate input file
+	if options.InputFile == "" {
+		return fmt.Errorf("input file is required")
+	}
+
+	// Ensure input file exists
+	if _, err := os.Stat(options.InputFile); os.IsNotExist(err) {
+		return fmt.Errorf("input file does not exist: %s", options.InputFile)
+	}
+
+	// Create CSV parser with appropriate options
+	csvParser := parser.NewCSVParser(options.InputFile)
+	filterOptions, err := buildFilterOptions(options)
+	if err != nil {
+		return fmt.Errorf("error configuring filters: %v", err)
+	}
+	csvParser.WithFilterOptions(filterOptions)
+
+	// Check file size to determine if we should use streaming
+	fileSize, err := csvParser.GetFileSize()
+	if err != nil {
+		return fmt.Errorf("error getting file size: %v", err)
+	}
+
+	// Suggest streaming mode for large files (>100MB) if not explicitly set
+	if fileSize > 100*1024*1024 && !options.UseStreaming {
+		fmt.Printf("Note: Processing a large file (%.2f MB). Consider using --stream for better performance.\n",
+			float64(fileSize)/(1024*1024))
+	}
+
+	// Get an estimate of the number of records
+	recordCount, err := csvParser.GetRecordCount()
+	if err != nil {
+		log.Printf("Warning: Couldn't estimate record count: %v", err)
+	} else {
+		fmt.Printf("Estimated records in file: %d\n", recordCount)
+	}
+
+	// Process the data
+	fmt.Printf("Processing data from %s...\n", options.InputFile)
+
+	var energyMetrics metrics.EnergyMetrics
+
+	// Configure metrics options
+	metricsOptions := buildMetricsOptions(options)
+
+	// Process data either with streaming or regular mode
+	if options.UseStreaming {
+		fmt.Println("Using streaming mode for memory-efficient processing...")
+		energyMetrics, err = metrics.StreamCalculateMetrics(csvParser, metricsOptions)
+		if err != nil {
+			return fmt.Errorf("failed to process CSV data in streaming mode: %v", err)
+		}
+	} else {
+		// Parse all records at once
+		records, err := csvParser.Parse()
+		if err != nil {
+			return fmt.Errorf("failed to parse CSV data: %v", err)
+		}
+		fmt.Printf("Successfully parsed %d records\n", len(records))
+
+		// Calculate metrics
+		calculator := metrics.NewEnergyCalculator(records).WithOptions(metricsOptions)
+		energyMetrics = calculator.CalculateMetrics()
+	}
+
+	// Generate appropriate output based on requested format and metrics
+	output, err := generateOutput(energyMetrics, options)
+	if err != nil {
+		return fmt.Errorf("failed to generate output: %v", err)
+	}
+
+	// Display or save the output
+	if options.OutputFile == "" {
+		fmt.Println(output)
+	} else {
+		err = os.WriteFile(options.OutputFile, []byte(output), 0644)
+		if err != nil {
+			return fmt.Errorf("failed to write output file: %v", err)
+		}
+		fmt.Printf("Results saved to %s\n", options.OutputFile)
+	}
+
+	return nil
+}
+
+// buildFilterOptions converts CLI options into parser filter options
+func buildFilterOptions(cliOptions CommandLineOptions) (parser.FilterOptions, error) {
+	filterOptions := parser.FilterOptions{
+		SampleRate: cliOptions.SampleRate,
+		MaxRecords: cliOptions.MaxRecords,
+	}
+
+	// Process time filters
+	if cliOptions.StartTime != "" {
+		startTime, err := parseTimeString(cliOptions.StartTime)
+		if err != nil {
+			return filterOptions, fmt.Errorf("invalid start time: %w", err)
+		}
+		filterOptions.StartTime = &startTime
+	}
+
+	if cliOptions.EndTime != "" {
+		endTime, err := parseTimeString(cliOptions.EndTime)
+		if err != nil {
+			return filterOptions, fmt.Errorf("invalid end time: %w", err)
+		}
+		filterOptions.EndTime = &endTime
+	}
+
+	// Process time window if specified
+	if cliOptions.TimeWindow != "" && filterOptions.EndTime == nil {
+		// Parse the time window (e.g., 1h, 30m, 24h)
+		duration, err := time.ParseDuration(cliOptions.TimeWindow)
+		if err != nil {
+			return filterOptions, fmt.Errorf("invalid time window: %w", err)
+		}
+
+		// If start time is specified, set end time relative to it
+		// Otherwise, set end time to now and start time relative to that
+		if filterOptions.StartTime != nil {
+			endTime := filterOptions.StartTime.Add(duration)
+			filterOptions.EndTime = &endTime
+		} else {
+			endTime := time.Now()
+			startTime := endTime.Add(-duration)
+			filterOptions.EndTime = &endTime
+			filterOptions.StartTime = &startTime
+		}
+	}
+
+	// Set temperature threshold if specified
+	if cliOptions.MinTemp > 0 {
+		filterOptions.TempThreshold = &cliOptions.MinTemp
+	}
+
+	// Set voltage range if specified
+	if cliOptions.VoltageMin != 0 || cliOptions.VoltageMax != 0 {
+		voltMin := cliOptions.VoltageMin
+		voltMax := cliOptions.VoltageMax
+
+		// If only min is specified, use very high max
+		if voltMin != 0 && voltMax == 0 {
+			voltMax = 1_000_000_000 // 1000V in µV
+		}
+
+		// If only max is specified, use very low min
+		if voltMin == 0 && voltMax != 0 {
+			voltMin = -1_000_000_000 // -1000V in µV
+		}
+
+		filterOptions.VoltageRange = &[2]int64{voltMin, voltMax}
+	}
+
+	// Set current range if specified
+	if cliOptions.CurrentMin != 0 || cliOptions.CurrentMax != 0 {
+		currMin := cliOptions.CurrentMin
+		currMax := cliOptions.CurrentMax
+
+		// If only min is specified, use very high max
+		if currMin != 0 && currMax == 0 {
+			currMax = 1_000_000_000_000 // 1000A in nA
+		}
+
+		// If only max is specified, use very low min
+		if currMin == 0 && currMax != 0 {
+			currMin = -1_000_000_000_000 // -1000A in nA
+		}
+
+		filterOptions.CurrentRange = &[2]int64{currMin, currMax}
+	}
+
+	return filterOptions, nil
+}
+
+// buildMetricsOptions converts CLI options into metrics calculation options
+func buildMetricsOptions(cliOptions CommandLineOptions) metrics.MetricsOptions {
+	options := metrics.MetricsOptions{
+		TimeResolution: time.Minute * 5, // Default 5-minute resolution
+	}
+
+	// Add specific metrics if requested
+	if cliOptions.Metric != "" {
+		metricType := metrics.MetricType(cliOptions.Metric)
+		options.RequestedMetrics = []metrics.MetricType{metricType}
+	}
+
+	return options
+}
+
+// generateOutput creates the appropriate output format based on user options
+func generateOutput(energyMetrics metrics.EnergyMetrics, options CommandLineOptions) (string, error) {
+	// If a specific metric was requested, extract just that
+	if options.Metric != "" {
+		metricType := metrics.MetricType(options.Metric)
+		specificMetric, err := metrics.GetSpecificMetric(energyMetrics, metricType)
+		if err != nil {
+			return "", err
+		}
+
+		// Format the specific metric according to output format
+		switch options.Format {
+		case FormatJSON:
+			jsonData, err := json.MarshalIndent(specificMetric, "", "  ")
+			if err != nil {
+				return "", fmt.Errorf("failed to marshal JSON: %w", err)
+			}
+			return string(jsonData), nil
+
+		case FormatCSV:
+			return formatMetricAsCSV(specificMetric, metricType)
+
+		default: // Text format
+			return formatMetricAsText(specificMetric, metricType), nil
+		}
+	}
+
+	// If no specific metric was requested, format the full report
+	switch options.Format {
+	case FormatJSON:
+		jsonData, err := json.MarshalIndent(energyMetrics, "", "  ")
+		if err != nil {
+			return "", fmt.Errorf("failed to marshal JSON: %w", err)
+		}
+		return string(jsonData), nil
+
+	case FormatCSV:
+		return generateCSVReport(energyMetrics)
+
+	default: // Text format
+		return generateReport(energyMetrics, options.InputFile), nil
+	}
+}
+
+// formatMetricAsCSV formats a specific metric in CSV format
+func formatMetricAsCSV(metric interface{}, metricType metrics.MetricType) (string, error) {
+	var sb strings.Builder
+
+	switch metricType {
+	case metrics.MetricTotalEnergy, metrics.MetricAveragePower, metrics.MetricPeakPower:
+		value, ok := metric.(float64)
+		if !ok {
+			return "", fmt.Errorf("unexpected type for %s", metricType)
+		}
+		sb.WriteString(fmt.Sprintf("%s,Value\n", metricType))
+		sb.WriteString(fmt.Sprintf("%s,%.6f\n", metricType, value))
+
+	case metrics.MetricTemperature:
+		tempStats, ok := metric.(metrics.TemperatureStats)
+		if !ok {
+			return "", fmt.Errorf("unexpected type for temperature stats")
+		}
+		sb.WriteString("Measurement,Value\n")
+		sb.WriteString(fmt.Sprintf("MinTemperature,%.2f\n", tempStats.MinTempCelsius))
+		sb.WriteString(fmt.Sprintf("MaxTemperature,%.2f\n", tempStats.MaxTempCelsius))
+		sb.WriteString(fmt.Sprintf("AvgTemperature,%.2f\n", tempStats.AvgTempCelsius))
+
+	case metrics.MetricEnergyByHour:
+		hourlyEnergy, ok := metric.(map[int]float64)
+		if !ok {
+			return "", fmt.Errorf("unexpected type for hourly energy")
+		}
+		sb.WriteString("Hour,EnergyJoules\n")
+		for h := 0; h < 24; h++ {
+			if energy, exists := hourlyEnergy[h]; exists {
+				sb.WriteString(fmt.Sprintf("%d,%.6f\n", h, energy))
+			}
+		}
+
+	case metrics.MetricVoltageStats:
+		voltStats, ok := metric.(metrics.VoltageStats)
+		if !ok {
+			return "", fmt.Errorf("unexpected type for voltage stats")
+		}
+		sb.WriteString("Measurement,Value\n")
+		sb.WriteString(fmt.Sprintf("MinVoltage,%.6f\n", voltStats.MinVoltage))
+		sb.WriteString(fmt.Sprintf("MaxVoltage,%.6f\n", voltStats.MaxVoltage))
+		sb.WriteString(fmt.Sprintf("AvgVoltage,%.6f\n", voltStats.AvgVoltage))
+
+	case metrics.MetricCurrentStats:
+		currentStats, ok := metric.(metrics.CurrentStats)
+		if !ok {
+			return "", fmt.Errorf("unexpected type for current stats")
+		}
+		sb.WriteString("Measurement,Value\n")
+		sb.WriteString(fmt.Sprintf("MinCurrent,%.9f\n", currentStats.MinCurrent))
+		sb.WriteString(fmt.Sprintf("MaxCurrent,%.9f\n", currentStats.MaxCurrent))
+		sb.WriteString(fmt.Sprintf("AvgCurrent,%.9f\n", currentStats.AvgCurrent))
+		sb.WriteString(fmt.Sprintf("MaxDischarge,%.9f\n", currentStats.MaxDischarge))
+		sb.WriteString(fmt.Sprintf("MaxCharging,%.9f\n", currentStats.MaxCharging))
+
+	case metrics.MetricBatteryDischarge:
+		batteryStats, ok := metric.(metrics.BatteryStats)
+		if !ok {
+			return "", fmt.Errorf("unexpected type for battery stats")
+		}
+		sb.WriteString("Measurement,Value\n")
+		sb.WriteString(fmt.Sprintf("TotalDischargeTime,%.2f\n", batteryStats.TotalDischargeTime))
+		sb.WriteString(fmt.Sprintf("TotalChargeTime,%.2f\n", batteryStats.TotalChargeTime))
+		sb.WriteString(fmt.Sprintf("DischargeToChargeRatio,%.6f\n", batteryStats.DischargeToChargeRatio))
+		sb.WriteString(fmt.Sprintf("AverageDischargeRate,%.6f\n", batteryStats.AverageDischargeRate))
+
+	case metrics.MetricSolarContribution:
+		solarStats, ok := metric.(metrics.SolarStats)
+		if !ok {
+			return "", fmt.Errorf("unexpected type for solar stats")
+		}
+		sb.WriteString("Measurement,Value\n")
+		sb.WriteString(fmt.Sprintf("TotalEnergyProduced,%.6f\n", solarStats.TotalEnergyProduced))
+		sb.WriteString(fmt.Sprintf("AverageOutput,%.6f\n", solarStats.AverageOutput))
+		sb.WriteString(fmt.Sprintf("PeakOutput,%.6f\n", solarStats.PeakOutput))
+		sb.WriteString(fmt.Sprintf("ContributionPercentage,%.2f\n", solarStats.ContributionPercentage))
+
+	default:
+		return "", fmt.Errorf("CSV formatting not supported for metric type: %s", metricType)
+	}
+
+	return sb.String(), nil
+}
+
+// formatMetricAsText formats a specific metric in human-readable text format
+func formatMetricAsText(metric interface{}, metricType metrics.MetricType) string {
+	var sb strings.Builder
+
+	sb.WriteString(fmt.Sprintf("===== %s =====\n", strings.ToUpper(string(metricType))))
+
+	switch metricType {
+	case metrics.MetricTotalEnergy:
+		value := metric.(float64)
+		sb.WriteString(fmt.Sprintf("Total Energy: %.4f joules\n", value))
+
+	case metrics.MetricAveragePower:
+		value := metric.(float64)
+		sb.WriteString(fmt.Sprintf("Average Power: %.4f watts\n", value))
+
+	case metrics.MetricPeakPower:
+		value := metric.(float64)
+		sb.WriteString(fmt.Sprintf("Peak Power: %.4f watts\n", value))
+
+	case metrics.MetricTemperature:
+		tempStats := metric.(metrics.TemperatureStats)
+		sb.WriteString(fmt.Sprintf("Minimum Temperature: %.2f °C\n", tempStats.MinTempCelsius))
+		sb.WriteString(fmt.Sprintf("Maximum Temperature: %.2f °C\n", tempStats.MaxTempCelsius))
+		sb.WriteString(fmt.Sprintf("Average Temperature: %.2f °C\n", tempStats.AvgTempCelsius))
+
+	case metrics.MetricEnergyByHour:
+		hourlyEnergy := metric.(map[int]float64)
+		sb.WriteString("Energy Consumption by Hour:\n")
+		for h := 0; h < 24; h++ {
+			if energy, exists := hourlyEnergy[h]; exists {
+				sb.WriteString(fmt.Sprintf("Hour %02d: %.4f joules\n", h, energy))
+			}
+		}
+
+	case metrics.MetricVoltageStats:
+		voltStats := metric.(metrics.VoltageStats)
+		sb.WriteString(fmt.Sprintf("Minimum Voltage: %.6f V\n", voltStats.MinVoltage))
+		sb.WriteString(fmt.Sprintf("Maximum Voltage: %.6f V\n", voltStats.MaxVoltage))
+		sb.WriteString(fmt.Sprintf("Average Voltage: %.6f V\n", voltStats.AvgVoltage))
+
+	case metrics.MetricCurrentStats:
+		currentStats := metric.(metrics.CurrentStats)
+		sb.WriteString(fmt.Sprintf("Minimum Current: %.9f A\n", currentStats.MinCurrent))
+		sb.WriteString(fmt.Sprintf("Maximum Current: %.9f A\n", currentStats.MaxCurrent))
+		sb.WriteString(fmt.Sprintf("Average Current: %.9f A\n", currentStats.AvgCurrent))
+		sb.WriteString(fmt.Sprintf("Maximum Discharge Current: %.9f A\n", currentStats.MaxDischarge))
+		sb.WriteString(fmt.Sprintf("Maximum Charging Current: %.9f A\n", currentStats.MaxCharging))
+
+	case metrics.MetricBatteryDischarge:
+		batteryStats := metric.(metrics.BatteryStats)
+		sb.WriteString(fmt.Sprintf("Total Discharge Time: %.2f seconds\n", batteryStats.TotalDischargeTime))
+		sb.WriteString(fmt.Sprintf("Total Charge Time: %.2f seconds\n", batteryStats.TotalChargeTime))
+		sb.WriteString(fmt.Sprintf("Discharge to Charge Ratio: %.2f%%\n", batteryStats.DischargeToChargeRatio*100))
+		sb.WriteString(fmt.Sprintf("Average Discharge Rate: %.4f watts\n", batteryStats.AverageDischargeRate))
+
+	case metrics.MetricSolarContribution:
+		solarStats := metric.(metrics.SolarStats)
+		sb.WriteString(fmt.Sprintf("Total Energy Produced: %.4f joules\n", solarStats.TotalEnergyProduced))
+		sb.WriteString(fmt.Sprintf("Average Output: %.4f watts\n", solarStats.AverageOutput))
+		sb.WriteString(fmt.Sprintf("Peak Output: %.4f watts\n", solarStats.PeakOutput))
+		sb.WriteString(fmt.Sprintf("Contribution to Energy: %.2f%%\n", solarStats.ContributionPercentage))
+
+	default:
+		sb.WriteString(fmt.Sprintf("No text formatter available for metric type: %s\n", metricType))
+	}
+
+	return sb.String()
+}
+
+// generateCSVReport creates a CSV report for all metrics
+func generateCSVReport(metrics metrics.EnergyMetrics) (string, error) {
+	var sb strings.Builder
+
+	sb.WriteString("Metric,Value\n")
+	sb.WriteString(fmt.Sprintf("TotalJoules,%.6f\n", metrics.TotalJoules))
+	sb.WriteString(fmt.Sprintf("AveragePowerWatts,%.6f\n", metrics.AveragePowerWatts))
+	sb.WriteString(fmt.Sprintf("PeakPowerWatts,%.6f\n", metrics.PeakPowerWatts))
+	sb.WriteString(fmt.Sprintf("JoulesPerDay,%.6f\n", metrics.JoulesPerDay))
+	sb.WriteString(fmt.Sprintf("DurationSeconds,%.2f\n", metrics.DurationSeconds))
+	sb.WriteString(fmt.Sprintf("DataPoints,%d\n", metrics.DataPoints))
+	sb.WriteString(fmt.Sprintf("StartTime,%s\n", metrics.TimeRange.StartTime.Format(time.RFC3339)))
+	sb.WriteString(fmt.Sprintf("EndTime,%s\n", metrics.TimeRange.EndTime.Format(time.RFC3339)))
+
+	sb.WriteString("\nTemperatureStats,Value\n")
+	sb.WriteString(fmt.Sprintf("MinTempCelsius,%.2f\n", metrics.TemperatureStats.MinTempCelsius))
+	sb.WriteString(fmt.Sprintf("MaxTempCelsius,%.2f\n", metrics.TemperatureStats.MaxTempCelsius))
+	sb.WriteString(fmt.Sprintf("AvgTempCelsius,%.2f\n", metrics.TemperatureStats.AvgTempCelsius))
+
+	sb.WriteString("\nVoltageStats,Value\n")
+	sb.WriteString(fmt.Sprintf("MinVoltage,%.6f\n", metrics.VoltageStats.MinVoltage))
+	sb.WriteString(fmt.Sprintf("MaxVoltage,%.6f\n", metrics.VoltageStats.MaxVoltage))
+	sb.WriteString(fmt.Sprintf("AvgVoltage,%.6f\n", metrics.VoltageStats.AvgVoltage))
+
+	sb.WriteString("\nCurrentStats,Value\n")
+	sb.WriteString(fmt.Sprintf("MinCurrent,%.9f\n", metrics.CurrentStats.MinCurrent))
+	sb.WriteString(fmt.Sprintf("MaxCurrent,%.9f\n", metrics.CurrentStats.MaxCurrent))
+	sb.WriteString(fmt.Sprintf("AvgCurrent,%.9f\n", metrics.CurrentStats.AvgCurrent))
+	sb.WriteString(fmt.Sprintf("MaxDischarge,%.9f\n", metrics.CurrentStats.MaxDischarge))
+	sb.WriteString(fmt.Sprintf("MaxCharging,%.9f\n", metrics.CurrentStats.MaxCharging))
+
+	sb.WriteString("\nBatteryStats,Value\n")
+	sb.WriteString(fmt.Sprintf("TotalDischargeTime,%.2f\n", metrics.BatteryStats.TotalDischargeTime))
+	sb.WriteString(fmt.Sprintf("TotalChargeTime,%.2f\n", metrics.BatteryStats.TotalChargeTime))
+	sb.WriteString(fmt.Sprintf("DischargeToChargeRatio,%.6f\n", metrics.BatteryStats.DischargeToChargeRatio))
+	sb.WriteString(fmt.Sprintf("AverageDischargeRate,%.6f\n", metrics.BatteryStats.AverageDischargeRate))
+
+	sb.WriteString("\nSolarStats,Value\n")
+	sb.WriteString(fmt.Sprintf("TotalEnergyProduced,%.6f\n", metrics.SolarStats.TotalEnergyProduced))
+	sb.WriteString(fmt.Sprintf("AverageOutput,%.6f\n", metrics.SolarStats.AverageOutput))
+	sb.WriteString(fmt.Sprintf("PeakOutput,%.6f\n", metrics.SolarStats.PeakOutput))
+	sb.WriteString(fmt.Sprintf("ContributionPercentage,%.2f\n", metrics.SolarStats.ContributionPercentage))
+
+	sb.WriteString("\nHour,EnergyJoules\n")
+	for h := 0; h < 24; h++ {
+		if energy, exists := metrics.EnergyConsumptionByHour[h]; exists {
+			sb.WriteString(fmt.Sprintf("%d,%.6f\n", h, energy))
+		}
+	}
+
+	return sb.String(), nil
+}
+
+// generateReport creates a human-readable report of the energy metrics
+func generateReport(metrics metrics.EnergyMetrics, inputFile string) string {
+	var sb strings.Builder
+
+	sb.WriteString("========== ENEMETER DATA PROCESSING REPORT ==========\n")
+	sb.WriteString(fmt.Sprintf("Input File: %s\n", filepath.Base(inputFile)))
+	sb.WriteString(fmt.Sprintf("Date: %s\n", time.Now().Format("2006-01-02 15:04:05")))
+	sb.WriteString(fmt.Sprintf("Data Points: %d\n", metrics.DataPoints))
+	sb.WriteString(fmt.Sprintf("Time Range: %s to %s\n\n",
+		metrics.TimeRange.StartTime.Format("2006-01-02 15:04:05"),
+		metrics.TimeRange.EndTime.Format("2006-01-02 15:04:05")))
+
+	sb.WriteString("ENERGY METRICS\n")
+	sb.WriteString("-------------\n")
+	sb.WriteString(fmt.Sprintf("Total Energy Consumed: %.4f joules\n", metrics.TotalJoules))
+	sb.WriteString(fmt.Sprintf("Average Power: %.4f watts\n", metrics.AveragePowerWatts))
+	sb.WriteString(fmt.Sprintf("Peak Power: %.4f watts\n", metrics.PeakPowerWatts))
+	sb.WriteString(fmt.Sprintf("Estimated Energy per Day: %.4f joules\n", metrics.JoulesPerDay))
+	sb.WriteString(fmt.Sprintf("Measurement Duration: %.2f seconds\n\n", metrics.DurationSeconds))
+
+	sb.WriteString("TEMPERATURE STATISTICS\n")
+	sb.WriteString("---------------------\n")
+	sb.WriteString(fmt.Sprintf("Minimum Temperature: %.2f °C\n", metrics.TemperatureStats.MinTempCelsius))
+	sb.WriteString(fmt.Sprintf("Maximum Temperature: %.2f °C\n", metrics.TemperatureStats.MaxTempCelsius))
+	sb.WriteString(fmt.Sprintf("Average Temperature: %.2f °C\n\n", metrics.TemperatureStats.AvgTempCelsius))
+
+	sb.WriteString("VOLTAGE STATISTICS\n")
+	sb.WriteString("----------------\n")
+	sb.WriteString(fmt.Sprintf("Minimum Voltage: %.6f V\n", metrics.VoltageStats.MinVoltage))
+	sb.WriteString(fmt.Sprintf("Maximum Voltage: %.6f V\n", metrics.VoltageStats.MaxVoltage))
+	sb.WriteString(fmt.Sprintf("Average Voltage: %.6f V\n\n", metrics.VoltageStats.AvgVoltage))
+
+	sb.WriteString("CURRENT STATISTICS\n")
+	sb.WriteString("----------------\n")
+	sb.WriteString(fmt.Sprintf("Minimum Current: %.9f A\n", metrics.CurrentStats.MinCurrent))
+	sb.WriteString(fmt.Sprintf("Maximum Current: %.9f A\n", metrics.CurrentStats.MaxCurrent))
+	sb.WriteString(fmt.Sprintf("Average Current: %.9f A\n", metrics.CurrentStats.AvgCurrent))
+	sb.WriteString(fmt.Sprintf("Maximum Discharge Current: %.9f A\n", metrics.CurrentStats.MaxDischarge))
+	sb.WriteString(fmt.Sprintf("Maximum Charging Current: %.9f A\n\n", metrics.CurrentStats.MaxCharging))
+
+	sb.WriteString("BATTERY STATISTICS\n")
+	sb.WriteString("------------------\n")
+	sb.WriteString(fmt.Sprintf("Total Discharge Time: %.2f seconds\n", metrics.BatteryStats.TotalDischargeTime))
+	sb.WriteString(fmt.Sprintf("Total Charge Time: %.2f seconds\n", metrics.BatteryStats.TotalChargeTime))
+	sb.WriteString(fmt.Sprintf("Discharge to Charge Ratio: %.2f%%\n", metrics.BatteryStats.DischargeToChargeRatio*100))
+	sb.WriteString(fmt.Sprintf("Average Discharge Rate: %.4f watts\n\n", metrics.BatteryStats.AverageDischargeRate))
+
+	sb.WriteString("SOLAR CONTRIBUTION\n")
+	sb.WriteString("-----------------\n")
+	sb.WriteString(fmt.Sprintf("Total Energy Produced: %.4f joules\n", metrics.SolarStats.TotalEnergyProduced))
+	sb.WriteString(fmt.Sprintf("Average Output: %.4f watts\n", metrics.SolarStats.AverageOutput))
+	sb.WriteString(fmt.Sprintf("Peak Output: %.4f watts\n", metrics.SolarStats.PeakOutput))
+	sb.WriteString(fmt.Sprintf("Contribution to Energy: %.2f%%\n\n", metrics.SolarStats.ContributionPercentage))
+
+	sb.WriteString("HOURLY ENERGY CONSUMPTION\n")
+	sb.WriteString("------------------------\n")
+
+	// Sort and print hourly consumption
+	if len(metrics.EnergyConsumptionByHour) > 0 {
+		for hour := 0; hour < 24; hour++ {
+			if joules, exists := metrics.EnergyConsumptionByHour[hour]; exists {
+				sb.WriteString(fmt.Sprintf("Hour %02d: %.4f joules\n", hour, joules))
+			}
+		}
+	} else {
+		sb.WriteString("No hourly data available\n")
+	}
+
+	return sb.String()
+}
+
+// parseTimeString parses a time string in the format YYYY-MM-DD[THH:MM:SS]
+func parseTimeString(timeStr string) (time.Time, error) {
+	layouts := []string{
+		"2006-01-02T15:04:05",
+		"2006-01-02 15:04:05",
+		"2006-01-02T15:04",
+		"2006-01-02 15:04",
+		"2006-01-02",
+	}
+
+	for _, layout := range layouts {
+		if t, err := time.Parse(layout, timeStr); err == nil {
+			return t, nil
+		}
+	}
+
+	return time.Time{}, fmt.Errorf("could not parse time using supported formats")
+}
diff --git a/internal/commands/version.go b/internal/commands/version.go
index eb5c756..b500944 100644
--- a/internal/commands/version.go
+++ b/internal/commands/version.go
@@ -1,3 +1,6 @@
 package commands
 
-var CurrentVersion = "v0.0.0"
+const (
+	CurrentVersion = "1.0.0"
+	AppName        = "ENEMETER Data Processing Tool"
+)
diff --git a/internal/metrics/energy_calc.go b/internal/metrics/energy_calc.go
new file mode 100644
index 0000000..49e8229
--- /dev/null
+++ b/internal/metrics/energy_calc.go
@@ -0,0 +1,377 @@
+package metrics
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	"enemeter-data-processing/internal/parser"
+)
+
+type MetricType string
+
+const (
+	MetricTotalEnergy       MetricType = "total_energy"
+	MetricAveragePower      MetricType = "average_power"
+	MetricPeakPower         MetricType = "peak_power"
+	MetricTemperature       MetricType = "temperature"
+	MetricEnergyByHour      MetricType = "energy_by_hour"
+	MetricVoltageStats      MetricType = "voltage_stats"
+	MetricCurrentStats      MetricType = "current_stats"
+	MetricBatteryDischarge  MetricType = "battery_discharge"
+	MetricSolarContribution MetricType = "solar_contribution"
+)
+
+type EnergyMetrics struct {
+	TotalJoules             float64
+	AveragePowerWatts       float64
+	PeakPowerWatts          float64
+	JoulesPerDay            float64
+	DurationSeconds         float64
+	TemperatureStats        TemperatureStats
+	EnergyConsumptionByHour map[int]float64
+	VoltageStats            VoltageStats
+	CurrentStats            CurrentStats
+	BatteryStats            BatteryStats
+	SolarStats              SolarStats
+	TimeRange               TimeRange
+	DataPoints              int
+}
+
+type TemperatureStats struct {
+	MinTempCelsius float64
+	MaxTempCelsius float64
+	AvgTempCelsius float64
+}
+
+type VoltageStats struct {
+	MinVoltage float64
+	MaxVoltage float64
+	AvgVoltage float64
+}
+
+type CurrentStats struct {
+	MinCurrent   float64
+	MaxCurrent   float64
+	AvgCurrent   float64
+	MaxDischarge float64
+	MaxCharging  float64
+}
+
+type BatteryStats struct {
+	EstimatedCapacity      float64
+	AverageDischargeRate   float64
+	TotalDischargeTime     float64
+	TotalChargeTime        float64
+	DischargeToChargeRatio float64
+}
+
+type SolarStats struct {
+	TotalEnergyProduced    float64
+	AverageOutput          float64
+	PeakOutput             float64
+	ContributionPercentage float64
+}
+
+type TimeRange struct {
+	StartTime time.Time
+	EndTime   time.Time
+}
+
+type MetricsOptions struct {
+	RequestedMetrics      []MetricType
+	TimeResolution        time.Duration
+	IncludeTimeSeriesData bool
+}
+
+type EnergyCalculator struct {
+	records   []parser.EnemeterRecord
+	options   MetricsOptions
+	streaming bool
+}
+
+func NewEnergyCalculator(records []parser.EnemeterRecord) *EnergyCalculator {
+	return &EnergyCalculator{
+		records:   records,
+		streaming: false,
+		options: MetricsOptions{
+			TimeResolution: time.Minute * 5,
+		},
+	}
+}
+
+func (e *EnergyCalculator) WithOptions(options MetricsOptions) *EnergyCalculator {
+	e.options = options
+	return e
+}
+
+func (e *EnergyCalculator) CalculateMetrics() EnergyMetrics {
+	if len(e.records) == 0 {
+		return EnergyMetrics{}
+	}
+
+	tracker := newMetricsTracker(e.options)
+
+	for i, record := range e.records {
+		tracker.processRecord(record, i)
+	}
+
+	return tracker.finalizeMetrics()
+}
+
+func StreamCalculateMetrics(p *parser.CSVParser, options MetricsOptions) (EnergyMetrics, error) {
+	tracker := newMetricsTracker(options)
+
+	recordIndex := 0
+
+	var processFunc = func(record parser.EnemeterRecord) error {
+		tracker.processRecord(record, recordIndex)
+		recordIndex++
+		return nil
+	}
+
+	err := p.StreamRecords(processFunc)
+
+	if err != nil {
+		return EnergyMetrics{}, fmt.Errorf("streaming calculation error: %w", err)
+	}
+
+	return tracker.finalizeMetrics(), nil
+}
+
+type metricsTracker struct {
+	options MetricsOptions
+
+	totalJoules     float64
+	totalPower      float64
+	peakPower       float64
+	totalDurationMs int64
+	dataPoints      int
+
+	startTime      time.Time
+	endTime        time.Time
+	firstTimestamp bool
+
+	tempSum   float64
+	minTemp   float64
+	maxTemp   float64
+	tempCount int
+
+	voltSum   float64
+	minVolt   float64
+	maxVolt   float64
+	voltCount int
+
+	currentSum   float64
+	minCurrent   float64
+	maxCurrent   float64
+	maxDischarge float64
+	maxCharging  float64
+	currentCount int
+
+	totalDischargeTime   float64
+	totalChargeTime      float64
+	totalDischargeEnergy float64
+	totalChargeEnergy    float64
+
+	energyByHour map[int]float64
+
+	prevRecord *parser.EnemeterRecord
+}
+
+func newMetricsTracker(options MetricsOptions) *metricsTracker {
+	return &metricsTracker{
+		options:        options,
+		energyByHour:   make(map[int]float64),
+		firstTimestamp: true,
+		minTemp:        math.MaxFloat64,
+		maxTemp:        -math.MaxFloat64,
+		minVolt:        math.MaxFloat64,
+		maxVolt:        -math.MaxFloat64,
+		minCurrent:     math.MaxFloat64,
+		maxCurrent:     -math.MaxFloat64,
+	}
+}
+
+func (mt *metricsTracker) processRecord(record parser.EnemeterRecord, index int) {
+	volts := float64(record.VoltageMicroV) / 1_000_000.0
+	amps := float64(record.CurrentNanoA) / 1_000_000_000.0
+	tempCelsius := float64(record.TempMiliCelsius) / 1000.0
+
+	if mt.firstTimestamp {
+		mt.startTime = record.Timestamp
+		mt.firstTimestamp = false
+	}
+
+	mt.endTime = record.Timestamp
+
+	mt.tempSum += tempCelsius
+	mt.tempCount++
+	if tempCelsius < mt.minTemp {
+		mt.minTemp = tempCelsius
+	}
+	if tempCelsius > mt.maxTemp {
+		mt.maxTemp = tempCelsius
+	}
+
+	mt.voltSum += volts
+	mt.voltCount++
+	if volts < mt.minVolt {
+		mt.minVolt = volts
+	}
+	if volts > mt.maxVolt {
+		mt.maxVolt = volts
+	}
+
+	mt.currentSum += amps
+	mt.currentCount++
+	if amps < mt.minCurrent {
+		mt.minCurrent = amps
+	}
+	if amps > mt.maxCurrent {
+		mt.maxCurrent = amps
+	}
+
+	if amps < 0 && math.Abs(amps) > mt.maxDischarge {
+		mt.maxDischarge = math.Abs(amps)
+	} else if amps > 0 && amps > mt.maxCharging {
+		mt.maxCharging = amps
+	}
+
+	instantPower := volts * amps
+
+	if math.Abs(instantPower) > mt.peakPower {
+		mt.peakPower = math.Abs(instantPower)
+	}
+
+	if mt.prevRecord != nil {
+		durationSecs := float64(record.TimeDeltaMs) / 1000.0
+		mt.totalDurationMs += record.TimeDeltaMs
+
+		joules := instantPower * durationSecs
+		mt.totalJoules += joules
+
+		mt.totalPower += instantPower
+
+		hourOfDay := record.Timestamp.Hour()
+		mt.energyByHour[hourOfDay] += joules
+
+		if amps < 0 {
+			mt.totalDischargeTime += durationSecs
+			mt.totalDischargeEnergy += math.Abs(joules)
+		} else {
+			mt.totalChargeTime += durationSecs
+			mt.totalChargeEnergy += joules
+		}
+	}
+
+	mt.prevRecord = &record
+	mt.dataPoints++
+}
+
+func (mt *metricsTracker) finalizeMetrics() EnergyMetrics {
+	metrics := EnergyMetrics{
+		EnergyConsumptionByHour: mt.energyByHour,
+		DataPoints:              mt.dataPoints,
+		TimeRange: TimeRange{
+			StartTime: mt.startTime,
+			EndTime:   mt.endTime,
+		},
+	}
+
+	durationSeconds := float64(mt.totalDurationMs) / 1000.0
+	metrics.TotalJoules = mt.totalJoules
+	metrics.PeakPowerWatts = mt.peakPower
+	metrics.DurationSeconds = durationSeconds
+
+	if durationSeconds > 0 {
+		metrics.AveragePowerWatts = mt.totalJoules / durationSeconds
+	}
+
+	if durationSeconds > 0 {
+		secondsPerDay := 24 * 60 * 60
+		metrics.JoulesPerDay = mt.totalJoules * (float64(secondsPerDay) / durationSeconds)
+	}
+
+	if mt.tempCount > 0 {
+		metrics.TemperatureStats = TemperatureStats{
+			MinTempCelsius: mt.minTemp,
+			MaxTempCelsius: mt.maxTemp,
+			AvgTempCelsius: mt.tempSum / float64(mt.tempCount),
+		}
+	}
+
+	if mt.voltCount > 0 {
+		metrics.VoltageStats = VoltageStats{
+			MinVoltage: mt.minVolt,
+			MaxVoltage: mt.maxVolt,
+			AvgVoltage: mt.voltSum / float64(mt.voltCount),
+		}
+	}
+
+	if mt.currentCount > 0 {
+		metrics.CurrentStats = CurrentStats{
+			MinCurrent:   mt.minCurrent,
+			MaxCurrent:   mt.maxCurrent,
+			AvgCurrent:   mt.currentSum / float64(mt.currentCount),
+			MaxDischarge: mt.maxDischarge,
+			MaxCharging:  mt.maxCharging,
+		}
+	}
+
+	metrics.BatteryStats = BatteryStats{
+		TotalDischargeTime: mt.totalDischargeTime,
+		TotalChargeTime:    mt.totalChargeTime,
+	}
+
+	totalTime := mt.totalDischargeTime + mt.totalChargeTime
+	if totalTime > 0 {
+		metrics.BatteryStats.DischargeToChargeRatio = mt.totalDischargeTime / totalTime
+	}
+
+	if mt.totalDischargeTime > 0 {
+		metrics.BatteryStats.AverageDischargeRate = mt.totalDischargeEnergy / mt.totalDischargeTime
+	}
+
+	metrics.SolarStats = SolarStats{
+		TotalEnergyProduced: mt.totalChargeEnergy,
+	}
+
+	if mt.totalChargeTime > 0 {
+		metrics.SolarStats.AverageOutput = mt.totalChargeEnergy / mt.totalChargeTime
+	}
+
+	metrics.SolarStats.PeakOutput = mt.maxCharging
+
+	totalEnergy := mt.totalDischargeEnergy + mt.totalChargeEnergy
+	if totalEnergy > 0 {
+		metrics.SolarStats.ContributionPercentage = (mt.totalChargeEnergy / totalEnergy) * 100
+	}
+
+	return metrics
+}
+
+func GetSpecificMetric(metrics EnergyMetrics, metricType MetricType) (interface{}, error) {
+	switch metricType {
+	case MetricTotalEnergy:
+		return metrics.TotalJoules, nil
+	case MetricAveragePower:
+		return metrics.AveragePowerWatts, nil
+	case MetricPeakPower:
+		return metrics.PeakPowerWatts, nil
+	case MetricTemperature:
+		return metrics.TemperatureStats, nil
+	case MetricEnergyByHour:
+		return metrics.EnergyConsumptionByHour, nil
+	case MetricVoltageStats:
+		return metrics.VoltageStats, nil
+	case MetricCurrentStats:
+		return metrics.CurrentStats, nil
+	case MetricBatteryDischarge:
+		return metrics.BatteryStats, nil
+	case MetricSolarContribution:
+		return metrics.SolarStats, nil
+	default:
+		return nil, fmt.Errorf("unknown metric type: %s", metricType)
+	}
+}
diff --git a/internal/parser/csv_parser.go b/internal/parser/csv_parser.go
new file mode 100644
index 0000000..8632747
--- /dev/null
+++ b/internal/parser/csv_parser.go
@@ -0,0 +1,315 @@
+package parser
+
+import (
+	"encoding/csv"
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"time"
+)
+
+type EnemeterRecord struct {
+	TimeDeltaMs     int64
+	TempMiliCelsius int64
+	VoltageMicroV   int64
+	CurrentNanoA    int64
+	Timestamp       time.Time
+}
+
+type FilterOptions struct {
+	StartTime      *time.Time
+	EndTime        *time.Time
+	SampleRate     int
+	MaxRecords     int
+	TempThreshold  *int64
+	VoltageRange   *[2]int64
+	CurrentRange   *[2]int64
+	SelectedFields []string
+}
+
+type CSVParser struct {
+	filePath string
+	options  FilterOptions
+}
+
+func NewCSVParser(filePath string) *CSVParser {
+	return &CSVParser{
+		filePath: filePath,
+		options: FilterOptions{
+			SampleRate: 1,
+		},
+	}
+}
+
+func (p *CSVParser) WithFilterOptions(options FilterOptions) *CSVParser {
+	p.options = options
+	return p
+}
+
+func (p *CSVParser) Parse() ([]EnemeterRecord, error) {
+	file, err := os.Open(p.filePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file: %w", err)
+	}
+	defer func() {
+		if closeErr := file.Close(); closeErr != nil {
+			// If we already have an error, we'll keep the original error
+			if err == nil {
+				err = fmt.Errorf("error closing file: %w", closeErr)
+			}
+		}
+	}()
+
+	reader := csv.NewReader(file)
+	var records []EnemeterRecord
+
+	baseTime := time.Now()
+	if p.options.StartTime != nil {
+		baseTime = *p.options.StartTime
+	}
+	accumulatedTimeMs := int64(0)
+	recordCount := 0
+	sampleCounter := 0
+
+	for p.options.MaxRecords <= 0 || len(records) < p.options.MaxRecords {
+		row, err := reader.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, fmt.Errorf("error reading CSV row: %w", err)
+		}
+
+		sampleCounter++
+		if sampleCounter < p.options.SampleRate {
+			continue
+		}
+		sampleCounter = 0
+
+		if len(row) != 4 {
+			return nil, fmt.Errorf("invalid row format, expected 4 fields but got %d", len(row))
+		}
+
+		timeDelta, err := strconv.ParseInt(row[0], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse time delta: %w", err)
+		}
+
+		tempMiliCelsius, err := strconv.ParseInt(row[1], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse temperature: %w", err)
+		}
+
+		voltageMicroV, err := strconv.ParseInt(row[2], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse voltage: %w", err)
+		}
+
+		currentNanoA, err := strconv.ParseInt(row[3], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse current: %w", err)
+		}
+
+		accumulatedTimeMs += timeDelta
+		timestamp := baseTime.Add(time.Duration(accumulatedTimeMs) * time.Millisecond)
+
+		if p.options.StartTime != nil && timestamp.Before(*p.options.StartTime) {
+			continue
+		}
+		if p.options.EndTime != nil && timestamp.After(*p.options.EndTime) {
+			break
+		}
+
+		if p.options.TempThreshold != nil && tempMiliCelsius < *p.options.TempThreshold {
+			continue
+		}
+
+		if p.options.VoltageRange != nil && (voltageMicroV < p.options.VoltageRange[0] || voltageMicroV > p.options.VoltageRange[1]) {
+			continue
+		}
+
+		if p.options.CurrentRange != nil && (currentNanoA < p.options.CurrentRange[0] || currentNanoA > p.options.CurrentRange[1]) {
+			continue
+		}
+
+		record := EnemeterRecord{
+			TimeDeltaMs:     timeDelta,
+			TempMiliCelsius: tempMiliCelsius,
+			VoltageMicroV:   voltageMicroV,
+			CurrentNanoA:    currentNanoA,
+			Timestamp:       timestamp,
+		}
+
+		records = append(records, record)
+		recordCount++
+	}
+
+	return records, nil
+}
+
+func (p *CSVParser) GetFileSize() (int64, error) {
+	fileInfo, err := os.Stat(p.filePath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to get file info: %w", err)
+	}
+	return fileInfo.Size(), nil
+}
+
+func (p *CSVParser) GetRecordCount() (int, error) {
+	file, err := os.Open(p.filePath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to open file: %w", err)
+	}
+	defer func() {
+		if closeErr := file.Close(); closeErr != nil {
+			if err == nil {
+				err = closeErr
+			}
+		}
+	}()
+
+	fileInfo, err := file.Stat()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get file info: %w", err)
+	}
+	fileSize := fileInfo.Size()
+
+	reader := csv.NewReader(file)
+	lineCount := 0
+	bytesRead := int64(0)
+
+	for i := 0; i < 100; i++ {
+		line, err := reader.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return 0, fmt.Errorf("error reading CSV: %w", err)
+		}
+
+		lineBytes := int64(0)
+		for _, field := range line {
+			lineBytes += int64(len(field) + 1)
+		}
+		lineBytes += 1
+
+		bytesRead += lineBytes
+		lineCount++
+	}
+
+	if lineCount == 0 {
+		return 0, nil
+	}
+
+	avgLineSize := bytesRead / int64(lineCount)
+	estimatedRecords := fileSize / avgLineSize
+
+	return int(estimatedRecords), nil
+}
+
+func (p *CSVParser) StreamRecords(callback func(record EnemeterRecord) error) error {
+	file, err := os.Open(p.filePath)
+	if err != nil {
+		return fmt.Errorf("failed to open file: %w", err)
+	}
+	defer func() {
+		if closeErr := file.Close(); closeErr != nil {
+			if err == nil {
+				err = fmt.Errorf("error closing file: %w", closeErr)
+			}
+		}
+	}()
+
+	reader := csv.NewReader(file)
+
+	baseTime := time.Now()
+	if p.options.StartTime != nil {
+		baseTime = *p.options.StartTime
+	}
+	accumulatedTimeMs := int64(0)
+	recordCount := 0
+	sampleCounter := 0
+
+	for {
+		row, err := reader.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("error reading CSV row: %w", err)
+		}
+
+		sampleCounter++
+		if sampleCounter < p.options.SampleRate {
+			continue
+		}
+		sampleCounter = 0
+
+		if p.options.MaxRecords > 0 && recordCount >= p.options.MaxRecords {
+			break
+		}
+
+		if len(row) != 4 {
+			return fmt.Errorf("invalid row format, expected 4 fields but got %d", len(row))
+		}
+
+		timeDelta, err := strconv.ParseInt(row[0], 10, 64)
+		if err != nil {
+			return fmt.Errorf("failed to parse time delta: %w", err)
+		}
+
+		tempMiliCelsius, err := strconv.ParseInt(row[1], 10, 64)
+		if err != nil {
+			return fmt.Errorf("failed to parse temperature: %w", err)
+		}
+
+		voltageMicroV, err := strconv.ParseInt(row[2], 10, 64)
+		if err != nil {
+			return fmt.Errorf("failed to parse voltage: %w", err)
+		}
+
+		currentNanoA, err := strconv.ParseInt(row[3], 10, 64)
+		if err != nil {
+			return fmt.Errorf("failed to parse current: %w", err)
+		}
+
+		accumulatedTimeMs += timeDelta
+		timestamp := baseTime.Add(time.Duration(accumulatedTimeMs) * time.Millisecond)
+
+		if p.options.StartTime != nil && timestamp.Before(*p.options.StartTime) {
+			continue
+		}
+		if p.options.EndTime != nil && timestamp.After(*p.options.EndTime) {
+			break
+		}
+
+		if p.options.TempThreshold != nil && tempMiliCelsius < *p.options.TempThreshold {
+			continue
+		}
+
+		if p.options.VoltageRange != nil && (voltageMicroV < p.options.VoltageRange[0] || voltageMicroV > p.options.VoltageRange[1]) {
+			continue
+		}
+
+		if p.options.CurrentRange != nil && (currentNanoA < p.options.CurrentRange[0] || currentNanoA > p.options.CurrentRange[1]) {
+			continue
+		}
+
+		record := EnemeterRecord{
+			TimeDeltaMs:     timeDelta,
+			TempMiliCelsius: tempMiliCelsius,
+			VoltageMicroV:   voltageMicroV,
+			CurrentNanoA:    currentNanoA,
+			Timestamp:       timestamp,
+		}
+
+		if err := callback(record); err != nil {
+			return fmt.Errorf("callback error: %w", err)
+		}
+
+		recordCount++
+	}
+
+	return nil
+}