// Copyright (C) 2023 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import m from 'mithril';

import {BigintMath} from '../base/bigint_math';
import {sqliteString} from '../base/string_utils';
import {duration, time} from '../base/time';
import {exists} from '../base/utils';
import {Anchor} from '../widgets/anchor';
import {MenuItem, PopupMenu2} from '../widgets/menu';
import {Section} from '../widgets/section';
import {SqlRef} from '../widgets/sql_ref';
import {Tree, TreeNode} from '../widgets/tree';

import {addTab} from './bottom_tab';
import {globals} from './globals';
import {SliceDetails} from './sql/slice';
import {
  BreakdownByThreadState,
  BreakdownByThreadStateTreeNode,
} from './sql/thread_state';
import {SqlTableTab} from './sql_table/tab';
import {SqlTables} from './sql_table/well_known_tables';
import {getProcessName, getThreadName} from './thread_and_process_info';
import {DurationWidget} from './widgets/duration';
import {Timestamp} from './widgets/timestamp';

function computeDuration(ts: time, dur: duration): m.Children {
  if (dur === -1n) {
    const minDuration = globals.state.traceTime.end - ts;
    return [m(DurationWidget, {dur: minDuration}), ' (Did not end)'];
  } else {
    return m(DurationWidget, {dur});
  }
}

// Renders a widget storing all of the generic details for a slice from the
// slice table.
export function renderDetails(
    slice: SliceDetails, durationBreakdown?: BreakdownByThreadState) {
  return m(
      Section,
      {title: 'Details'},
      m(
          Tree,
          m(TreeNode, {
            left: 'Name',
            right: m(
                PopupMenu2,
                {
                  trigger: m(Anchor, slice.name),
                },
                m(MenuItem, {
                  label: 'Slices with the same name',
                  onclick: () => {
                    addTab({
                      kind: SqlTableTab.kind,
                      config: {
                        table: SqlTables.slice,
                        displayName: 'slice',
                        filters: [`name = ${sqliteString(slice.name)}`],
                      },
                    });
                  },
                }),
                ),
          }),
          m(TreeNode, {
            left: 'Category',
            right: !slice.category || slice.category === '[NULL]' ?
                'N/A' :
                slice.category,
          }),
          m(TreeNode, {
            left: 'Start time',
            right: m(Timestamp, {ts: slice.ts}),
          }),
          exists(slice.absTime) &&
              m(TreeNode, {left: 'Absolute Time', right: slice.absTime}),
          m(
              TreeNode,
              {
                left: 'Duration',
                right: computeDuration(slice.ts, slice.dur),
              },
              exists(durationBreakdown) && slice.dur > 0 &&
                  m(BreakdownByThreadStateTreeNode, {
                    data: durationBreakdown,
                    dur: slice.dur,
                  }),
              ),
          renderThreadDuration(slice),
          slice.thread && m(TreeNode, {
            left: 'Thread',
            right: getThreadName(slice.thread),
          }),
          slice.process && m(TreeNode, {
            left: 'Process',
            right: getProcessName(slice.process),
          }),
          slice.process && exists(slice.process.uid) && m(TreeNode, {
            left: 'User ID',
            right: slice.process.uid,
          }),
          slice.process && slice.process.packageName && m(TreeNode, {
            left: 'Package name',
            right: slice.process.packageName,
          }),
          slice.process && exists(slice.process.versionCode) && m(TreeNode, {
            left: 'Version code',
            right: slice.process.versionCode,
          }),
          m(TreeNode, {
            left: 'SQL ID',
            right: m(SqlRef, {table: 'slice', id: slice.id}),
          }),
          ));
}

function renderThreadDuration(sliceInfo: SliceDetails) {
  if (exists(sliceInfo.threadTs) && exists(sliceInfo.threadDur)) {
    // If we have valid thread duration, also display a percentage of
    // |threadDur| compared to |dur|.
    const ratio = BigintMath.ratio(sliceInfo.threadDur, sliceInfo.dur);
    const threadDurFractionSuffix =
        sliceInfo.threadDur === -1n ? '' : ` (${(ratio * 100).toFixed(2)}%)`;
    return m(TreeNode, {
      left: 'Thread duration',
      right: [
        computeDuration(sliceInfo.threadTs, sliceInfo.threadDur),
        threadDurFractionSuffix,
      ],
    });
  } else {
    return undefined;
  }
}