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/forecast"
	"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"
)

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       []forecast.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) {
	store, err := defaultStore(req.Config)
	if err != nil {
		return state.Metadata{}, err
	}
	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
	return metadata, err
}

func InspectBriefing(ctx context.Context, req InspectRunRequest) (briefing.Package, error) {
	store, err := defaultStore(req.Config)
	if err != nil {
		return briefing.Package{}, err
	}
	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
	if err != nil {
		return briefing.Package{}, err
	}
	return store.LoadBriefing(ctx, metadata.BriefingPath)
}

func InspectDataPackage(ctx context.Context, req InspectRunRequest) (promptinput.Package, error) {
	store, err := defaultStore(req.Config)
	if err != nil {
		return promptinput.Package{}, err
	}
	metadata, _, err := store.LoadMetadataByRunID(ctx, req.RunID)
	if err != nil {
		return promptinput.Package{}, err
	}
	return store.LoadDataPackage(ctx, metadata.DataPackagePath)
}

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

func InspectSources(ctx context.Context, req InspectRunRequest) (SourceInspection, error) {
	metadata, err := InspectMetadata(ctx, req)
	if err != nil {
		return SourceInspection{}, err
	}
	return SourceInspection{
		RunID:          metadata.RunID,
		ReportID:       metadata.ReportID,
		SourceLocation: metadata.SourceLocation,
		Sources:        metadata.Sources,
		Warnings:       metadata.SourceWarnings,
	}, 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
}