package app

import (
	"context"
	"fmt"

	"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/promptinput"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/state"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
)

type InspectReportsRequest struct {
	Config config.Config
	Limit  int
}

type InspectRunRequest struct {
	Config config.Config
	RunID  string
}

type SourceInspection struct {
	RunID          string                      `json:"runId"`
	ReportID       report.ID                   `json:"reportId"`
	SourceLocation string                      `json:"sourceLocation,omitempty"`
	Sources        []briefing.SourceMetadata   `json:"sources,omitempty"`
	Warnings       []weatherdata.SourceWarning `json:"warnings,omitempty"`
}

func InspectReports(ctx context.Context, req InspectReportsRequest) ([]state.ReportRecord, error) {
	store, err := defaultStore(req.Config)
	if err != nil {
		return nil, err
	}
	return store.ListReports(ctx, req.Limit)
}

func InspectMetadata(ctx context.Context, req InspectRunRequest) (state.Metadata, error) {
	inspection, err := inspectRun(ctx, req)
	return inspection.metadata, err
}

func InspectModules(ctx context.Context, req InspectRunRequest) (module.Snapshot, error) {
	inspection, err := inspectRun(ctx, req)
	if err != nil {
		return module.Snapshot{}, err
	}
	return inspection.store.LoadModuleSnapshot(ctx, inspection.metadata.ModuleSnapshotPath)
}

func InspectDataPackage(ctx context.Context, req InspectRunRequest) (promptinput.Package, error) {
	inspection, err := inspectRun(ctx, req)
	if err != nil {
		return promptinput.Package{}, err
	}
	return inspection.store.LoadDataPackage(ctx, inspection.metadata.DataPackagePath)
}

func InspectPriorSnapshot(ctx context.Context, req InspectRunRequest) (*state.PriorSnapshot, error) {
	inspection, err := inspectRun(ctx, req)
	if err != nil {
		return nil, err
	}
	resolved, err := resolvedFromMetadata(inspection.metadata)
	if err != nil {
		return nil, err
	}
	return inspection.store.FindPriorSnapshot(ctx, resolved)
}

func InspectSources(ctx context.Context, req InspectRunRequest) (SourceInspection, error) {
	inspection, err := inspectRun(ctx, req)
	if err != nil {
		return SourceInspection{}, err
	}
	metadata := inspection.metadata
	return SourceInspection{
		RunID:          metadata.RunID,
		ReportID:       metadata.ReportID,
		SourceLocation: metadata.SourceLocation,
		Sources:        metadata.Sources,
		Warnings:       metadata.SourceWarnings,
	}, nil
}

type runInspection struct {
	store    *state.FilesystemStore
	metadata state.Metadata
}

func inspectRun(ctx context.Context, req InspectRunRequest) (runInspection, error) {
	store, err := defaultStore(req.Config)
	if err != nil {
		return runInspection{}, err
	}
	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
	if err != nil {
		return runInspection{}, err
	}
	return runInspection{store: store, metadata: metadata}, nil
}

func resolvedFromMetadata(metadata state.Metadata) (report.Resolved, error) {
	definition, err := report.DefaultRegistry().Lookup(metadata.ReportID)
	if err != nil {
		return report.Resolved{}, err
	}
	location, err := timeutil.LoadLocation(metadata.Timezone)
	if err != nil {
		return report.Resolved{}, err
	}
	if !metadata.ValidPeriod.IsValid() {
		return report.Resolved{}, fmt.Errorf("metadata valid period for run id %q is invalid", metadata.RunID)
	}
	return report.Resolved{
		Definition:  definition,
		GeneratedAt: metadata.GeneratedAt,
		Timezone:    location.String(),
		ValidPeriod: metadata.ValidPeriod,
	}, nil
}