inspectioncore_impl

var InspectionTimeProducer common_task.Task[time.Time] = common_task.NewTask(inspectioncore_contract.InspectionTimeTaskID, []taskid.UntypedTaskReference{}, func(ctx context.Context) (time.Time, error) {
	return time.Now(), nil
})

var SerializeTask = inspectiontaskbase.NewProgressReportableInspectionTask(inspectioncore_contract.SerializerTaskID, []taskid.UntypedTaskReference{}, func(ctx context.Context, taskMode inspectioncore_contract.InspectionTaskModeType, progress *inspectionmetadata.TaskProgressMetadata) (*inspectioncore_contract.FileSystemStore, error) {
	if taskMode == inspectioncore_contract.TaskModeDryRun {
		slog.DebugContext(ctx, "Skipping because this is in dryrun mode")
		return nil, nil
	}
	inspectionID := khictx.MustGetValue(ctx, inspectioncore_contract.InspectionTaskInspectionID)
	metadataSet := khictx.MustGetValue(ctx, inspectioncore_contract.InspectionRunMetadata)
	ioConfig := khictx.MustGetValue(ctx, inspectioncore_contract.CurrentIOConfig)
	builder := khictx.MustGetValue(ctx, inspectioncore_contract.Builder)

	for _, key := range metadataSet.Keys() {
		metadata, found := typedmap.Get(metadataSet, inspectionmetadata.NewMetadataLabelsKey[inspectionmetadata.Metadata](key))
		if !found {
			return nil, fmt.Errorf("expected metadata not found: %s", key)
		}
		if err := builder.MetadataAccumulator.AddMetadata(metadata); err != nil {
			return nil, err
		}
	}

	store := inspectioncore_contract.NewFileSystemInspectionResultRepository(filepath.Join(ioConfig.DataDestination, inspectionID+".khi"))
	writer, err := store.GetWriter()
	if err != nil {
		return nil, err
	}

	if err := builder.Build(writer, &taskProgressReporter{progress: progress}); err != nil {
		writer.Close()
		return nil, err
	}

	if err := writer.Close(); err != nil {
		return nil, err
	}

	fileSize, err := store.GetInspectionResultSizeInBytes()
	if err != nil {
		return nil, err
	}

	header, found := typedmap.Get(metadataSet, inspectionmetadata.HeaderMetadataKey)
	if found {
		header.FileSize = fileSize
	}
	return store, nil
})

var TestInspectionTimeTaskProducer func(timeStr string) common_task.Task[time.Time] = func(timeStr string) common_task.Task[time.Time] {
	return common_task.NewTask(inspectioncore_contract.InspectionTimeTaskID, []taskid.UntypedTaskReference{}, func(ctx context.Context) (time.Time, error) {
		t, err := time.Parse(time.RFC3339, timeStr)
		if err != nil {
			return time.Time{}, err
		}
		return t, nil
	})
}

var TimeZoneShiftInputTask = inspectiontaskbase.NewInspectionTask(inspectioncore_contract.TimeZoneShiftInputTaskID, []taskid.UntypedTaskReference{}, func(ctx context.Context, taskMode inspectioncore_contract.InspectionTaskModeType) (*time.Location, error) {
	req := khictx.MustGetValue(ctx, inspectioncore_contract.InspectionTaskInput)
	if tzShiftAny, found := req["timezoneShift"]; found {
		if tzShiftFloat, convertible := tzShiftAny.(float64); convertible {
			return time.FixedZone("Unknown", int(tzShiftFloat*3600)), nil
		} else {
			return time.UTC, nil
		}
	} else {
		return time.UTC, nil
	}
})