#!/usr/bin/env python3

from __future__ import annotations

import statistics
import sys
from csv import DictReader, DictWriter
from dataclasses import asdict, dataclass, fields
from pathlib import Path

MAPPING: dict[str, str] = {
	"ca-c-clang": "clang",
	"ca-c-gcc": "gcc",
	"ca-cpp-clang": "clang++",
	"ca-cpp-gcc": "g++",
	"ca-fortran-gcc": "gfortran",
	"ca-fortran-llvm-flang": "flang-new",
	"ca-julia": "julia",
	"rodinia-srad-c-clang": "clang",
	"rodinia-srad-c-gcc": "gcc",
	"rodinia-srad-cpp-clang": "clang++",
	"rodinia-srad-cpp-gcc": "g++",
	"rodinia-srad-fortran-gcc": "gfortran",
	"rodinia-srad-fortran-llvm-flang": "flang-new",
	"rodinia-srad-julia": "julia",
}


@dataclass
class Input(object):
	thread: str
	region_idf: str
	file: str
	line: str
	function: str
	visits: str
	device_name: str
	energy: str
	time: str


@dataclass
class Result(object):
	name: str

	energy_min: float
	energy_avg: float
	energy_max: float
	energy_std: float
	energy_var: float

	time_min: float
	time_avg: float
	time_max: float
	time_std: float
	time_var: float

	memory_min: float
	memory_avg: float
	memory_max: float
	memory_std: float
	memory_var: float


def main(args: list[str]) -> int:
	path: Path = Path(args[0])
	programs: list[Path] = [x for x in path.glob("*") if x.is_dir()]

	with (path / "combined.csv").open("w") as f:
		combined: DictWriter = DictWriter(
			f, [x.name for x in fields(Result)], delimiter=" "
		)
		combined.writeheader()

		for program in sorted(programs):
			energy: list[float] = []
			time: list[float] = []
			memory: list[float] = []

			name: str = MAPPING[program.name]

			with (path / f"{name}.csv").open("w") as r:
				runs: DictWriter = DictWriter(
					r, ["run", "energy", "time", "memory"], delimiter=" "
				)
				runs.writeheader()

				for run in sorted(program.glob("*")):
					m: float = int((run / "memory_usage.txt").read_text()) / 1024
					memory.append(m)

					ema: Path = next(run.glob("output.EMA.*"))
					with ema.open() as f:
						reader: DictReader = DictReader(f)

						for line in reader:
							input: Input = Input(**line)

							if input.device_name != args[1]:
								continue

							e: float = int(input.energy) / 1000 / 1000 / 1000
							t: float = int(input.time) / 1000 / 1000

							runs.writerow(
								{"run": run.name, "energy": e, "time": t, "memory": m}
							)

							energy.append(e)
							time.append(t)

				result: Result = Result(
					name=MAPPING[program.name],
					energy_min=min(energy),
					energy_avg=statistics.mean(energy),
					energy_max=max(energy),
					energy_std=statistics.stdev(energy),
					energy_var=statistics.variance(energy),
					time_min=min(time),
					time_avg=statistics.mean(time),
					time_max=max(time),
					time_std=statistics.stdev(time),
					time_var=statistics.variance(time),
					memory_min=min(memory),
					memory_avg=statistics.mean(memory),
					memory_max=max(memory),
					memory_std=statistics.stdev(memory),
					memory_var=statistics.variance(memory),
				)

				combined.writerow(asdict(result))

	return 0


if __name__ == "__main__":
	sys.exit(main(sys.argv[1:]))