// 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 {
  Plugin,
  PluginContext,
  PluginContextTrace,
  PluginDescriptor,
} from '../../public';
import {EngineProxy} from '../../trace_processor/engine';
import {SimpleSliceTrack, SimpleSliceTrackConfig} from '../../frontend/simple_slice_track';
import {SimpleCounterTrack, SimpleCounterTrackConfig} from '../../frontend/simple_counter_track';

const DEFAULT_NETWORK = `
  with base as (
      select
          ts,
          substr(s.name, 6) as conn
      from track t join slice s on t.id = s.track_id
      where t.name = 'battery_stats.conn'
  ),
  diff as (
      select
          ts,
          conn,
          conn != lag(conn) over (order by ts) as keep
      from base
  )
  select
      ts,
      ifnull(lead(ts) over (order by ts), (select end_ts from trace_bounds)) - ts as dur,
      case
        when conn like '-1:%' then 'Disconnected'
        when conn like '0:%' then 'Modem'
        when conn like '1:%' then 'WiFi'
        when conn like '4:%' then 'VPN'
        else conn
      end as name
  from diff where keep is null or keep`;

const TETHERING = `
  with base as (
      select
          ts as ts_end,
          EXTRACT_ARG(arg_set_id, 'network_tethering_reported.duration_millis') * 1000000 as dur
      from track t join slice s on t.id = s.track_id
      where t.name = 'Statsd Atoms'
        and s.name = 'network_tethering_reported'
  )
  select ts_end - dur as ts, dur, 'Tethering' as name from base`;

const NETWORK_SUMMARY = `
  drop table if exists network_summary;
  create table network_summary as
  with base as (
      select
          cast(s.ts / 5000000000 as int) * 5000000000 as ts,
          case
              when t.name glob '*wlan*' then 'wifi'
              when t.name glob '*rmnet*' then 'modem'
              else 'unknown'
          end as dev_type,
          lower(substr(t.name, instr(t.name, ' ') + 1, 1)) || 'x' as dir,
          sum(EXTRACT_ARG(arg_set_id, 'packet_length')) AS value
      from slice s join track t on s.track_id = t.id
      where (t.name glob '*Received' or t.name glob '*Transmitted')
      and (t.name glob '*wlan*' or t.name glob '*rmnet*')
      group by 1,2,3
  ),
  zeroes as (
      select
          ts,
          dev_type,
          dir,
          value
      from base
      union all
      select
          ts + 5000000000 as ts,
          dev_type,
          dir,
          0 as value
      from base
  ),
  final as (
      select
          ts,
          dev_type,
          dir,
          sum(value) as value
      from zeroes
      group by 1, 2, 3
  )
  select * from final where ts is not null`;

const MODEM_ACTIVITY_INFO = `
  drop table if exists modem_activity_info;
  create table modem_activity_info as
  with modem_raw as (
    select
      ts,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.timestamp_millis') as timestamp_millis,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.sleep_time_millis') as sleep_time_millis,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.controller_idle_time_millis') as controller_idle_time_millis,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.controller_tx_time_pl0_millis') as controller_tx_time_pl0_millis,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.controller_tx_time_pl1_millis') as controller_tx_time_pl1_millis,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.controller_tx_time_pl2_millis') as controller_tx_time_pl2_millis,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.controller_tx_time_pl3_millis') as controller_tx_time_pl3_millis,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.controller_tx_time_pl4_millis') as controller_tx_time_pl4_millis,
      EXTRACT_ARG(arg_set_id, 'modem_activity_info.controller_rx_time_millis') as controller_rx_time_millis
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
      and s.name = 'modem_activity_info'
  ),
  deltas as (
      select
          timestamp_millis * 1000000 as ts,
          lead(timestamp_millis) over (order by ts) - timestamp_millis as dur_millis,
          lead(sleep_time_millis) over (order by ts) - sleep_time_millis as sleep_time_millis,
          lead(controller_idle_time_millis) over (order by ts) - controller_idle_time_millis as controller_idle_time_millis,
          lead(controller_tx_time_pl0_millis) over (order by ts) - controller_tx_time_pl0_millis as controller_tx_time_pl0_millis,
          lead(controller_tx_time_pl1_millis) over (order by ts) - controller_tx_time_pl1_millis as controller_tx_time_pl1_millis,
          lead(controller_tx_time_pl2_millis) over (order by ts) - controller_tx_time_pl2_millis as controller_tx_time_pl2_millis,
          lead(controller_tx_time_pl3_millis) over (order by ts) - controller_tx_time_pl3_millis as controller_tx_time_pl3_millis,
          lead(controller_tx_time_pl4_millis) over (order by ts) - controller_tx_time_pl4_millis as controller_tx_time_pl4_millis,
          lead(controller_rx_time_millis) over (order by ts) - controller_rx_time_millis as controller_rx_time_millis
      from modem_raw
  ),
  ratios as (
      select
          ts,
          100.0 * sleep_time_millis / dur_millis as sleep_time_ratio,
          100.0 * controller_idle_time_millis / dur_millis as controller_idle_time_ratio,
          100.0 * controller_tx_time_pl0_millis / dur_millis as controller_tx_time_pl0_ratio,
          100.0 * controller_tx_time_pl1_millis / dur_millis as controller_tx_time_pl1_ratio,
          100.0 * controller_tx_time_pl2_millis / dur_millis as controller_tx_time_pl2_ratio,
          100.0 * controller_tx_time_pl3_millis / dur_millis as controller_tx_time_pl3_ratio,
          100.0 * controller_tx_time_pl4_millis / dur_millis as controller_tx_time_pl4_ratio,
          100.0 * controller_rx_time_millis / dur_millis as controller_rx_time_ratio
      from deltas
  )
  select * from ratios where sleep_time_ratio is not null and sleep_time_ratio >= 0`;

const MODEM_RIL_STRENGTH = `
  DROP VIEW IF EXISTS ScreenOn;
  CREATE VIEW ScreenOn AS
  SELECT ts, dur FROM (
      SELECT
          ts, value,
          LEAD(ts, 1, TRACE_END()) OVER (ORDER BY ts)-ts AS dur
      FROM counter, track ON (counter.track_id = track.id)
      WHERE track.name = 'ScreenState'
  ) WHERE value = 2;

  DROP VIEW IF EXISTS RilSignalStrength;
  CREATE VIEW RilSignalStrength AS
  With RilMessages AS (
      SELECT
          ts, slice.name,
          LEAD(ts, 1, TRACE_END()) OVER (ORDER BY ts)-ts AS dur
      FROM slice, track
      ON (slice.track_id = track.id)
      WHERE track.name = 'RIL'
        AND slice.name GLOB 'UNSOL_SIGNAL_STRENGTH*'
  ),
  BandTypes(band_ril, band_name) AS (
      VALUES ("CellSignalStrengthLte:", "LTE"),
              ("CellSignalStrengthNr:", "NR")
  ),
  ValueTypes(value_ril, value_name) AS (
      VALUES ("rsrp=", "rsrp"),
              ("rssi=", "rssi")
  ),
  Extracted AS (
      SELECT ts, dur, band_name, value_name, (
          SELECT CAST(SUBSTR(key_str, start_idx+1, end_idx-start_idx-1) AS INT64) AS value
          FROM (
              SELECT key_str, INSTR(key_str, "=") AS start_idx, INSTR(key_str, " ") AS end_idx
              FROM (
                  SELECT SUBSTR(band_str, INSTR(band_str, value_ril)) AS key_str
                  FROM (SELECT SUBSTR(name, INSTR(name, band_ril)) AS band_str)
              )
          )
      ) AS value
      FROM RilMessages
      JOIN BandTypes
      JOIN ValueTypes
  )
  SELECT
  ts, dur, band_name, value_name, value,
  value_name || "=" || IIF(value = 2147483647, "unknown", ""||value) AS name,
  ROW_NUMBER() OVER (ORDER BY ts) as id,
  DENSE_RANK() OVER (ORDER BY band_name, value_name) AS track_id
  FROM Extracted;

  DROP TABLE IF EXISTS RilScreenOn;
  CREATE VIRTUAL TABLE RilScreenOn
  USING SPAN_JOIN(RilSignalStrength PARTITIONED track_id, ScreenOn)`;

const MODEM_RIL_CHANNELS_PREAMBLE = `
  CREATE OR REPLACE PERFETTO FUNCTION EXTRACT_KEY_VALUE(source STRING, key_name STRING) RETURNS STRING AS
  SELECT SUBSTR(trimmed, INSTR(trimmed, "=")+1, INSTR(trimmed, ",") - INSTR(trimmed, "=") - 1)
  FROM (SELECT SUBSTR($source, INSTR($source, $key_name)) AS trimmed);`;

const MODEM_RIL_CHANNELS = `
  With RawChannelConfig AS (
      SELECT ts, slice.name AS raw_config
      FROM slice, track
      ON (slice.track_id = track.id)
      WHERE track.name = 'RIL'
      AND slice.name LIKE 'UNSOL_PHYSICAL_CHANNEL_CONFIG%'
  ),
  Attributes(attribute, attrib_name) AS (
      VALUES ("mCellBandwidthDownlinkKhz", "downlink"),
          ("mCellBandwidthUplinkKhz", "uplink"),
          ("mNetworkType", "network"),
          ("mBand", "band")
  ),
  Slots(idx, slot_name) AS (
      VALUES (0, "primary"),
          (1, "secondary 1"),
          (2, "secondary 2")
  ),
  Stage1 AS (
      SELECT *, IFNULL(EXTRACT_KEY_VALUE(STR_SPLIT(raw_config, "}, {", idx), attribute), "") AS name
      FROM RawChannelConfig
      JOIN Attributes
      JOIN Slots
  ),
  Stage2 AS (
      SELECT *, LAG(name) OVER (PARTITION BY idx, attribute ORDER BY ts) AS last_name
      FROM Stage1
  ),
  Stage3 AS (
      SELECT *, LEAD(ts, 1, TRACE_END()) OVER (PARTITION BY idx, attribute ORDER BY ts) - ts AS dur
      FROM Stage2 WHERE name != last_name
  )
  SELECT ts, dur, slot_name || "-" || attrib_name || "=" || name AS name
  FROM Stage3`;

const MODEM_CELL_RESELECTION = `
  with base as (
    select
        ts,
        s.name as raw_ril,
        ifnull(str_split(str_split(s.name, 'CellIdentityLte{', 1), ', operatorNames', 0),
            str_split(str_split(s.name, 'CellIdentityNr{', 1), ', operatorNames', 0)) as cell_id
    from track t join slice s on t.id = s.track_id
    where t.name = 'RIL' and s.name like '%DATA_REGISTRATION_STATE%'
  ),
  base2 as (
    select
        ts,
        raw_ril,
        case
            when cell_id like '%earfcn%' then 'LTE ' || cell_id
            when cell_id like '%nrarfcn%' then 'NR ' || cell_id
            when cell_id is null then 'Unknown'
            else cell_id
        end as cell_id
    from base
  ),
  base3 as (
    select ts, cell_id , lag(cell_id) over (order by ts) as lag_cell_id, raw_ril
    from base2
  )
  select ts, 0 as dur, cell_id as name, raw_ril
  from base3
  where cell_id != lag_cell_id
  order by ts`;

const SUSPEND_RESUME = `
  SELECT
    ts,
    dur,
    'Suspended' AS name
  FROM android_suspend_state
  WHERE power_state = 'suspended'`;

const SCREEN_STATE = `
  WITH _counter AS (
    SELECT counter.id, ts, 0 AS track_id, value
    FROM counter
    JOIN counter_track ON counter_track.id = counter.track_id
    WHERE name = 'ScreenState'
  )
  SELECT
    ts,
    dur,
    CASE value
      WHEN 1 THEN 'Screen off'
      WHEN 2 THEN 'Screen on'
      WHEN 3 THEN 'Always-on display (doze)'
      ELSE 'unknown'
    END AS name
  FROM counter_leading_intervals!(_counter)`;

// See DeviceIdleController.java for where these states come from and how
// they transition.
const DOZE_LIGHT = `
  WITH _counter AS (
    SELECT counter.id, ts, 0 AS track_id, value
    FROM counter
    JOIN counter_track ON counter_track.id = counter.track_id
    WHERE name = 'DozeLightState'
  )
  SELECT
    ts,
    dur,
    CASE value
      WHEN 0 THEN 'active'
      WHEN 1 THEN 'inactive'
      WHEN 4 THEN 'idle'
      WHEN 5 THEN 'waiting_for_network'
      WHEN 6 THEN 'idle_maintenance'
      WHEN 7 THEN 'override'
      ELSE 'unknown'
    END AS name
  FROM counter_leading_intervals!(_counter)`;

const DOZE_DEEP = `
  WITH _counter AS (
    SELECT counter.id, ts, 0 AS track_id, value
    FROM counter
    JOIN counter_track ON counter_track.id = counter.track_id
    WHERE name = 'DozeDeepState'
  )
  SELECT
    ts,
    dur,
    CASE value
      WHEN 0 THEN 'active'
      WHEN 1 THEN 'inactive'
      WHEN 2 THEN 'idle_pending'
      WHEN 3 THEN 'sensing'
      WHEN 4 THEN 'locating'
      WHEN 5 THEN 'idle'
      WHEN 6 THEN 'idle_maintenance'
      WHEN 7 THEN 'quick_doze_delay'
      ELSE 'unknown'
    END AS name
  FROM counter_leading_intervals!(_counter)`;

const CHARGING = `
  WITH _counter AS (
    SELECT counter.id, ts, 0 AS track_id, value
    FROM counter
    JOIN counter_track ON counter_track.id = counter.track_id
    WHERE name = 'BatteryStatus'
  )
  SELECT
    ts,
    dur,
    CASE value
      -- 0 and 1 are both unknown
      WHEN 2 THEN 'Charging'
      WHEN 3 THEN 'Discharging'
      -- special case when charger is present but battery isn't charging
      WHEN 4 THEN 'Not charging'
      WHEN 5 THEN 'Full'
      ELSE 'unknown'
    END AS name
  FROM counter_leading_intervals!(_counter)`;

const THERMAL_THROTTLING = `
  with step1 as (
      select
          ts,
          EXTRACT_ARG(arg_set_id, 'thermal_throttling_severity_state_changed.sensor_type') as sensor_type,
          EXTRACT_ARG(arg_set_id, 'thermal_throttling_severity_state_changed.sensor_name') as sensor_name,
          EXTRACT_ARG(arg_set_id, 'thermal_throttling_severity_state_changed.temperature_deci_celsius') / 10.0 as temperature_celcius,
          EXTRACT_ARG(arg_set_id, 'thermal_throttling_severity_state_changed.severity') as severity
      from track t join slice s on t.id = s.track_id
      where t.name = 'Statsd Atoms'
      and s.name = 'thermal_throttling_severity_state_changed'
  ),
  step2 as (
      select
          ts,
          lead(ts) over (partition by sensor_type, sensor_name order by ts) - ts as dur,
          sensor_type,
          sensor_name,
          temperature_celcius,
          severity
      from step1
      where sensor_type not like 'TEMPERATURE_TYPE_BCL_%'
  )
  select
    ts,
    dur,
    case sensor_name
        when 'VIRTUAL-SKIN' then ''
        else sensor_name || ' is '
    end || severity || ' (' || temperature_celcius || 'C)' as name
  from step2
  where severity != 'NONE'`;

const KERNEL_WAKELOCKS = `
  drop table if exists kernel_wakelocks;
  create table kernel_wakelocks as
  with step1 as (
    select
      ts,
      EXTRACT_ARG(arg_set_id, 'kernel_wakelock.name') as wakelock_name,
      EXTRACT_ARG(arg_set_id, 'kernel_wakelock.count') as count,
      EXTRACT_ARG(arg_set_id, 'kernel_wakelock.time_micros') as time_micros
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
      and s.name = 'kernel_wakelock'
  ),
  step2 as (
    select
      ts,
      wakelock_name,
      lead(ts) over (partition by wakelock_name order by ts) as ts_end,
      lead(count) over (partition by wakelock_name order by ts) - count as count,
      (lead(time_micros) over (partition by wakelock_name order by ts) - time_micros) * 1000 as wakelock_dur
    from step1
  ),
  step3 as (
    select
      ts,
      ts_end,
      ifnull((select sum(dur) from android_suspend_state s
              where power_state = 'suspended'
                and s.ts > step2.ts
                and s.ts < step2.ts_end), 0) as suspended_dur,
      wakelock_name,
      count,
      wakelock_dur
    from step2
    where wakelock_dur is not null
      and wakelock_dur > 0
      and count >= 0
  ),
  step4 as (
    select
      ts,
      ts_end,
      suspended_dur,
      wakelock_name,
      count,
      1.0 * wakelock_dur / (ts_end - ts - suspended_dur) as ratio,
      wakelock_dur
    from step3
  )
  select
    ts,
    min(ratio, 1) * (ts_end - ts) as dur,
    wakelock_name,
    cast (100.0 * ratio as int) || '% (+' || count || ')' as name
    from step4
  where cast (100.0 * wakelock_dur / (ts_end - ts - suspended_dur) as int) > 1`;

const KERNEL_WAKELOCKS_SUMMARY = `
  select distinct wakelock_name
  from kernel_wakelocks
  where wakelock_name not in ('PowerManager.SuspendLockout', 'PowerManagerService.Display')
  order by 1;`;

const HIGH_CPU = `
  drop table if exists high_cpu;
  create table high_cpu as
  with base as (
    select
      ts,
      EXTRACT_ARG(arg_set_id, 'cpu_cycles_per_uid_cluster.uid') as uid,
      EXTRACT_ARG(arg_set_id, 'cpu_cycles_per_uid_cluster.cluster') as cluster,
      sum(EXTRACT_ARG(arg_set_id, 'cpu_cycles_per_uid_cluster.time_millis')) as time_millis
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
      and s.name = 'cpu_cycles_per_uid_cluster'
    group by 1, 2, 3
  ),
  with_windows as (
    select
      ts,
      uid,
      cluster,
      lead(ts) over (partition by uid, cluster order by ts) - ts as dur,
      (lead(time_millis) over (partition by uid, cluster order by ts) - time_millis) * 1000000.0 as cpu_dur
    from base
  ),
  app_package_list as (
    select
      uid,
      group_concat(package_name) as package_name
    from package_list
    where uid >= 10000
    group by 1
  ),
  with_ratio as (
    select
      ts,
      100.0 * cpu_dur / dur as value,
      dur,
      case cluster when 0 then 'little' when 1 then 'mid' when 2 then 'big' else 'cl-' || cluster end as cluster,
      case
          when uid = 0 then 'AID_ROOT'
          when uid = 1000 then 'AID_SYSTEM_USER'
          when uid = 1001 then 'AID_RADIO'
          when uid = 1082 then 'AID_ARTD'
          when pl.package_name is null then 'uid=' || uid
          else pl.package_name
      end as pkg
    from with_windows left join app_package_list pl using(uid)
    where cpu_dur is not null
  ),
  with_zeros as (
      select ts, value, cluster, pkg
      from with_ratio
      union all
      select ts + dur as ts, 0 as value, cluster, pkg
      from with_ratio
  )
  select ts, sum(value) as value, cluster, pkg
  from with_zeros
  group by 1, 3, 4`;

const WAKEUPS = `
  drop table if exists wakeups;
  create table wakeups as
  with wakeup_reason as (
      select
      ts,
      substr(i.name, 0, instr(i.name, ' ')) as id_timestamp,
      substr(i.name, instr(i.name, ' ') + 1) as raw_wakeup
      from track t join instant i on t.id = i.track_id
      where t.name = 'wakeup_reason'
  ),
  wakeup_attribution as (
      select
      substr(i.name, 0, instr(i.name, ' ')) as id_timestamp,
      substr(i.name, instr(i.name, ' ') + 1) as attribution
      from track t join instant i on t.id = i.track_id
      where t.name = 'wakeup_attribution'
  ),
  step1 as(
    select
      ts,
      raw_wakeup,
      attribution,
      null as raw_backoff
    from wakeup_reason r
      left outer join wakeup_attribution using(id_timestamp)
    union all
    select
      ts,
      null as raw_wakeup,
      null as attribution,
      i.name as raw_backoff
    from track t join instant i on t.id = i.track_id
    where t.name = 'suspend_backoff'
  ),
  step2 as (
    select
      ts,
      raw_wakeup,
      attribution,
      lag(raw_backoff) over (order by ts) as raw_backoff
    from step1
  ),
  step3 as (
    select
      ts,
      raw_wakeup,
      attribution,
      str_split(raw_backoff, ' ', 0) as suspend_quality,
      str_split(raw_backoff, ' ', 1) as backoff_state,
      str_split(raw_backoff, ' ', 2) as backoff_reason,
      cast(str_split(raw_backoff, ' ', 3) as int) as backoff_count,
      cast(str_split(raw_backoff, ' ', 4) as int) as backoff_millis,
      false as suspend_end
    from step2
    where raw_wakeup is not null
    union all
    select
      ts,
      null as raw_wakeup,
      null as attribution,
      null as suspend_quality,
      null as backoff_state,
      null as backoff_reason,
      null as backoff_count,
      null as backoff_millis,
      true as suspend_end
    from android_suspend_state
    where power_state = 'suspended'
  ),
  step4 as (
    select
      ts,
      case suspend_quality
        when 'good' then
          min(
            lead(ts, 1, ts + 5e9) over (order by ts) - ts,
            5e9
          )
        when 'bad' then backoff_millis * 1000000
        else 0
      end as dur,
      raw_wakeup,
      attribution,
      suspend_quality,
      backoff_state,
      backoff_reason,
      backoff_count,
      backoff_millis,
      suspend_end
    from step3
  ),
  step5 as (
    select
      ts,
      dur,
      raw_wakeup,
      attribution,
      suspend_quality,
      backoff_state,
      backoff_reason,
      backoff_count,
      backoff_millis
    from step4
    where not suspend_end
  ),
  step6 as (
    select
      ts,
      dur,
      raw_wakeup,
      attribution,
      suspend_quality,
      backoff_state,
      backoff_reason,
      backoff_count,
      backoff_millis,
      case
        when raw_wakeup like 'Abort: Pending Wakeup Sources: %' then 'abort_pending'
        when raw_wakeup like 'Abort: Last active Wakeup Source: %' then 'abort_last_active'
        when raw_wakeup like 'Abort: %' then 'abort_other'
        else 'normal'
      end as type,
      case
        when raw_wakeup like 'Abort: Pending Wakeup Sources: %' then substr(raw_wakeup, 32)
        when raw_wakeup like 'Abort: Last active Wakeup Source: %' then substr(raw_wakeup, 35)
        when raw_wakeup like 'Abort: %' then substr(raw_wakeup, 8)
        else raw_wakeup
      end as main,
      case
        when raw_wakeup like 'Abort: Pending Wakeup Sources: %' then ' '
        when raw_wakeup like 'Abort: %' then 'no delimiter needed'
        else ':'
      end as delimiter
    from step5
  ),
  step7 as (
    select
      ts,
      dur,
      raw_wakeup,
      attribution,
      suspend_quality,
      backoff_state,
      backoff_reason,
      backoff_count,
      backoff_millis,
      type,
      str_split(main, delimiter, 0) as item_0,
      str_split(main, delimiter, 1) as item_1,
      str_split(main, delimiter, 2) as item_2,
      str_split(main, delimiter, 3) as item_3
    from step6
  ),
  step8 as (
    select ts, dur, raw_wakeup, attribution, suspend_quality, backoff_state, backoff_reason, backoff_count, backoff_millis, type, item_0 as item from step7
    union all
    select ts, dur, raw_wakeup, attribution, suspend_quality, backoff_state, backoff_reason, backoff_count, backoff_millis, type, item_1 as item from step7 where item_1 is not null
    union all
    select ts, dur, raw_wakeup, attribution, suspend_quality, backoff_state, backoff_reason, backoff_count, backoff_millis, type, item_2 as item from step7 where item_2 is not null
    union all
    select ts, dur, raw_wakeup, attribution, suspend_quality, backoff_state, backoff_reason, backoff_count, backoff_millis, type, item_3 as item from step7 where item_3 is not null
  )
  select
    ts,
    dur,
    ts + dur as ts_end,
    raw_wakeup,
    attribution,
    suspend_quality,
    backoff_state,
    ifnull(backoff_reason, 'none') as backoff_reason,
    backoff_count,
    backoff_millis,
    type,
    case when type = 'normal' then ifnull(str_split(item, ' ', 1), item) else item end as item
  from step8`;

const WAKEUPS_COLUMNS = [
  'item',
  'type',
  'raw_wakeup',
  'attribution',
  'suspend_quality',
  'backoff_state',
  'backoff_reason',
  'backoff_count',
  'backoff_millis',
];

function bleScanQuery(condition: string) {
  return `
  with step1 as (
      select
          ts,
          extract_arg(arg_set_id, 'ble_scan_state_changed.attribution_node[0].tag') as name,
          extract_arg(arg_set_id, 'ble_scan_state_changed.is_opportunistic') as opportunistic,
          extract_arg(arg_set_id, 'ble_scan_state_changed.is_filtered') as filtered,
          extract_arg(arg_set_id, 'ble_scan_state_changed.state') as state
      from track t join slice s on t.id = s.track_id
      where t.name = 'Statsd Atoms'
      and s.name = 'ble_scan_state_changed'
  ),
  step2 as (
      select
          ts,
          name,
          state,
          opportunistic,
          filtered,
          lead(ts) over (partition by name order by ts) - ts as dur
      from step1
  )
  select ts, dur, name from step2 where state = 'ON' and ${
  condition} and dur is not null`;
}

const BLE_RESULTS = `
  with step1 as (
      select
          ts,
          extract_arg(arg_set_id, 'ble_scan_result_received.attribution_node[0].tag') as name,
          extract_arg(arg_set_id, 'ble_scan_result_received.num_results') as num_results
      from track t join slice s on t.id = s.track_id
      where t.name = 'Statsd Atoms'
      and s.name = 'ble_scan_result_received'
  )
  select
      ts,
      0 as dur,
      name || ' (' || num_results || ' results)' as name
  from step1`;

const BT_A2DP_AUDIO = `
  with step1 as (
    select
        ts,
        EXTRACT_ARG(arg_set_id, 'bluetooth_a2dp_playback_state_changed.playback_state') as playback_state,
        EXTRACT_ARG(arg_set_id, 'bluetooth_a2dp_playback_state_changed.audio_coding_mode') as audio_coding_mode,
        EXTRACT_ARG(arg_set_id, 'bluetooth_a2dp_playback_state_changed.metric_id') as metric_id
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
    and s.name = 'bluetooth_a2dp_playback_state_changed'
  ),
  step2 as (
    select
        ts,
        lead(ts) over (partition by metric_id order by ts) - ts as dur,
        playback_state,
        audio_coding_mode,
        metric_id
    from step1
  )
  select
    ts,
    dur,
    audio_coding_mode as name
  from step2
  where playback_state = 'PLAYBACK_STATE_PLAYING'`;

const BT_CONNS_ACL = `
    with acl1 as (
        select
            ts,
            EXTRACT_ARG(arg_set_id, 'bluetooth_acl_connection_state_changed.state') as state,
            EXTRACT_ARG(arg_set_id, 'bluetooth_acl_connection_state_changed.transport') as transport,
            EXTRACT_ARG(arg_set_id, 'bluetooth_acl_connection_state_changed.metric_id') as metric_id
        from track t join slice s on t.id = s.track_id
        where t.name = 'Statsd Atoms'
        and s.name = 'bluetooth_acl_connection_state_changed'
    ),
    acl2 as (
        select
            ts,
            lead(ts) over (partition by metric_id, transport order by ts) - ts as dur,
            state,
            transport,
            metric_id
        from acl1
    )
    select
        ts,
        dur,
        'Device ' || metric_id ||
          ' (' || case transport when 'TRANSPORT_TYPE_BREDR' then 'Classic' when 'TRANSPORT_TYPE_LE' then 'BLE' end || ')' as name
    from acl2
    where state != 'CONNECTION_STATE_DISCONNECTED' and dur is not null`;

const BT_CONNS_SCO = `
  with sco1 as (
    select
        ts,
        EXTRACT_ARG(arg_set_id, 'bluetooth_sco_connection_state_changed.state') as state,
        EXTRACT_ARG(arg_set_id, 'bluetooth_sco_connection_state_changed.codec') as codec,
        EXTRACT_ARG(arg_set_id, 'bluetooth_sco_connection_state_changed.metric_id') as metric_id
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
    and s.name = 'bluetooth_sco_connection_state_changed'
  ),
  sco2 as (
    select
        ts,
        lead(ts) over (partition by metric_id, codec order by ts) - ts as dur,
        state,
        codec,
        metric_id
    from sco1
  )
  select
    ts,
    dur,
    case state when 'CONNECTION_STATE_CONNECTED' then '' when 'CONNECTION_STATE_CONNECTING' then 'Connecting ' when 'CONNECTION_STATE_DISCONNECTING' then 'Disconnecting ' else 'unknown ' end ||
      'Device ' || metric_id || ' (' ||
      case codec when 'SCO_CODEC_CVSD' then 'CVSD' when 'SCO_CODEC_MSBC' then 'MSBC' end || ')' as name
  from sco2
  where state != 'CONNECTION_STATE_DISCONNECTED' and dur is not null`;

const BT_LINK_LEVEL_EVENTS = `
  with base as (
    select
        ts,
        EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.direction') as direction,
        EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.type') as type,
        EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.hci_cmd') as hci_cmd,
        EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.hci_event') as hci_event,
        EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.hci_ble_event') as hci_ble_event,
        EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.cmd_status') as cmd_status,
        EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.reason_code') as reason_code,
        EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.metric_id') as metric_id
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
    and s.name = 'bluetooth_link_layer_connection_event'
  )
  select
    *,
    0 as dur,
    'Device '|| metric_id as name
  from base`;

const BT_LINK_LEVEL_EVENTS_COLUMNS = [
  'direction',
  'type',
  'hci_cmd',
  'hci_event',
  'hci_ble_event',
  'cmd_status',
  'reason_code',
  'metric_id',
];

const BT_QUALITY_REPORTS = `
  with base as (
      select
          ts,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.quality_report_id') as quality_report_id,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.packet_types') as packet_types,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.connection_handle') as connection_handle,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.connection_role') as connection_role,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.tx_power_level') as tx_power_level,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.rssi') as rssi,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.snr') as snr,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.unused_afh_channel_count') as unused_afh_channel_count,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.afh_select_unideal_channel_count') as afh_select_unideal_channel_count,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.lsto') as lsto,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.connection_piconet_clock') as connection_piconet_clock,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.retransmission_count') as retransmission_count,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.no_rx_count') as no_rx_count,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.nak_count') as nak_count,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.flow_off_count') as flow_off_count,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.buffer_overflow_bytes') as buffer_overflow_bytes,
          EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.buffer_underflow_bytes') as buffer_underflow_bytes
      from track t join slice s on t.id = s.track_id
      where t.name = 'Statsd Atoms'
      and s.name = 'bluetooth_quality_report_reported'
  )
  select
      *,
      0 as dur,
      'Connection '|| connection_handle as name
  from base`;

const BT_QUALITY_REPORTS_COLUMNS = [
  'quality_report_id',
  'packet_types',
  'connection_handle',
  'connection_role',
  'tx_power_level',
  'rssi',
  'snr',
  'unused_afh_channel_count',
  'afh_select_unideal_channel_count',
  'lsto',
  'connection_piconet_clock',
  'retransmission_count',
  'no_rx_count',
  'nak_count',
  'flow_off_count',
  'buffer_overflow_bytes',
  'buffer_underflow_bytes',
];

const BT_RSSI_REPORTS = `
  with base as (
    select
        ts,
        EXTRACT_ARG(arg_set_id, 'bluetooth_device_rssi_reported.connection_handle') as connection_handle,
        EXTRACT_ARG(arg_set_id, 'bluetooth_device_rssi_reported.hci_status') as hci_status,
        EXTRACT_ARG(arg_set_id, 'bluetooth_device_rssi_reported.rssi') as rssi,
        EXTRACT_ARG(arg_set_id, 'bluetooth_device_rssi_reported.metric_id') as metric_id
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
    and s.name = 'bluetooth_device_rssi_reported'
  )
  select
    *,
    0 as dur,
    'Connection '|| connection_handle as name
  from base`;

const BT_RSSI_REPORTS_COLUMNS =
    ['connection_handle', 'hci_status', 'rssi', 'metric_id'];

const BT_CODE_PATH_COUNTER = `
  with base as (
    select
        ts,
        EXTRACT_ARG(arg_set_id, 'bluetooth_code_path_counter.key') as key,
        EXTRACT_ARG(arg_set_id, 'bluetooth_code_path_counter.number') as number
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
    and s.name = 'bluetooth_code_path_counter'
  )
  select
    *,
    0 as dur,
    key as name
  from base`;

const BT_CODE_PATH_COUNTER_COLUMNS = ['key', 'number'];

const BT_HAL_CRASHES = `
  with base as (
      select
          ts,
          EXTRACT_ARG(arg_set_id, 'bluetooth_hal_crash_reason_reported.metric_id') as metric_id,
          EXTRACT_ARG(arg_set_id, 'bluetooth_hal_crash_reason_reported.error_code') as error_code,
          EXTRACT_ARG(arg_set_id, 'bluetooth_hal_crash_reason_reported.vendor_error_code') as vendor_error_code
      from track t join slice s on t.id = s.track_id
      where t.name = 'Statsd Atoms'
      and s.name = 'bluetooth_hal_crash_reason_reported'
  )
  select
      *,
      0 as dur,
      'Device ' || metric_id as name
  from base`;

const BT_HAL_CRASHES_COLUMNS = ['metric_id', 'error_code', 'vendor_error_code'];

const BT_BYTES = `
  with step1 as (
    select
        ts,
        EXTRACT_ARG(arg_set_id, 'bluetooth_bytes_transfer.uid') as uid,
        EXTRACT_ARG(arg_set_id, 'bluetooth_bytes_transfer.tx_bytes') as tx_bytes,
        EXTRACT_ARG(arg_set_id, 'bluetooth_bytes_transfer.rx_bytes') as rx_bytes
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
    and s.name = 'bluetooth_bytes_transfer'
  ),
  step2 as (
    select
        ts,
        lead(ts) over (partition by uid order by ts) - ts as dur,
        uid,
        lead(tx_bytes) over (partition by uid order by ts) - tx_bytes as tx_bytes,
        lead(rx_bytes) over (partition by uid order by ts) - rx_bytes as rx_bytes
    from step1
  ),
  step3 as (
    select
        ts,
        dur,
        uid % 100000 as uid,
        sum(tx_bytes) as tx_bytes,
        sum(rx_bytes) as rx_bytes
    from step2
    where tx_bytes >=0 and rx_bytes >=0
    group by 1,2,3
    having tx_bytes > 0 or rx_bytes > 0
  ),
  app_package_list as (
  select
    uid,
    group_concat(package_name) as package_name
  from package_list
  where uid >= 10000
  group by 1
  )
    select
        ts,
        dur,
        case
            when pl.package_name is null then 'uid=' || uid
            else pl.package_name
        end || ' TX ' || tx_bytes || ' bytes / RX ' || rx_bytes || ' bytes' as name
    from step3 left join app_package_list pl using(uid)
`;

const BT_ACTIVITY = `
  with step1 as (
    select
        EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.timestamp_millis') * 1000000 as ts,
        case EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.bluetooth_stack_state')
        when 1 then 'active'
        when 2 then 'scanning'
        when 3 then 'idle'
        else 'invalid'
        end as bluetooth_stack_state,
        EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.controller_idle_time_millis') * 1000000 as controller_idle_dur,
        EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.controller_tx_time_millis') * 1000000 as controller_tx_dur,
        EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.controller_rx_time_millis') * 1000000 as controller_rx_dur
    from track t join slice s on t.id = s.track_id
    where t.name = 'Statsd Atoms'
    and s.name = 'bluetooth_activity_info'
  ),
  step2 as (
    select
        ts,
        lead(ts) over (order by ts) - ts as dur,
        bluetooth_stack_state,
        lead(controller_idle_dur) over (order by ts) - controller_idle_dur as controller_idle_dur,
        lead(controller_tx_dur) over (order by ts) - controller_tx_dur as controller_tx_dur,
        lead(controller_rx_dur) over (order by ts) - controller_rx_dur as controller_rx_dur
    from step1
  )
  select
    ts,
    dur * controller_rx_dur / dur as dur,
    cast(100.0 * controller_rx_dur / dur as int) || '% RX, ' ||
        cast(100.0 * controller_tx_dur / dur as int) || '% TX, ' || bluetooth_stack_state as name
  from step2
  where controller_rx_dur > 0
`;

class AndroidLongBatteryTracing implements Plugin {
  onActivate(_: PluginContext): void {}

  addSliceTrack(
    ctx: PluginContextTrace,
    name: string,
    query: string,
    groupName?: string,
    columns: string[] = []): void {
    const config: SimpleSliceTrackConfig = {
      data: {
        sqlSource: query,
        columns: ['ts', 'dur', 'name', ...columns],
      },
      columns: {ts: 'ts', dur: 'dur', name: 'name'},
      argColumns: columns,
    };
    ctx.registerStaticTrack({
      uri: `dev.perfetto.AndroidLongBatteryTracing#${name}`,
      displayName: name,
      trackFactory: (trackCtx) => {
        return new SimpleSliceTrack(ctx.engine, trackCtx, config);
      },
      groupName,
    });
  }

  addCounterTrack(
    ctx: PluginContextTrace, name: string, query: string,
    groupName: string): void {
    const config: SimpleCounterTrackConfig = {
      data: {
        sqlSource: query,
        columns: ['ts', 'value'],
      },
      columns: {ts: 'ts', value: 'value'},
    };
    ctx.registerStaticTrack({
      uri: `dev.perfetto.AndroidLongBatteryTracing#${name}`,
      displayName: name,
      trackFactory: (trackCtx) => {
        return new SimpleCounterTrack(ctx.engine, trackCtx, config);
      },
      groupName,
    });
  }

  addBatteryStatsState(
    ctx: PluginContextTrace, name: string, track: string, groupName: string,
    features: Set<string>): void {
    if (!features.has(`track.${track}`)) {
      return;
    }
    this.addSliceTrack(
      ctx, name, `SELECT ts, dur, value_name AS name
    FROM android_battery_stats_state
    WHERE track_name = "${track}"`,
      groupName);
  }

  addBatteryStatsEvent(
    ctx: PluginContextTrace,
    name: string,
    track: string,
    groupName: string|undefined,
    features: Set<string>): void {
    if (!features.has(`track.${track}`)) {
      return;
    }

    this.addSliceTrack(
      ctx, name, `SELECT ts, dur, str_value AS name
    FROM android_battery_stats_event_slices
    WHERE track_name = "${track}"`,
      groupName);
  }

  async addDeviceState(ctx: PluginContextTrace, features: Set<string>):
      Promise<void> {
    if (!features.has('track.battery_stats.*')) {
      return;
    }

    const query =
        (name: string, track: string) =>
          this.addBatteryStatsEvent(ctx, name, track, undefined, features);

    const e = ctx.engine;
    await e.query(`INCLUDE PERFETTO MODULE android.battery_stats;`);
    await e.query(`INCLUDE PERFETTO MODULE android.suspend;`);
    await e.query(`INCLUDE PERFETTO MODULE counters.intervals;`);

    this.addSliceTrack(ctx, 'Device State: Screen state', SCREEN_STATE);
    this.addSliceTrack(ctx, 'Device State: Charging', CHARGING);
    this.addSliceTrack(ctx, 'Device State: Suspend / resume', SUSPEND_RESUME);
    this.addSliceTrack(ctx, 'Device State: Doze light state', DOZE_LIGHT);
    this.addSliceTrack(ctx, 'Device State: Doze deep state', DOZE_DEEP);

    query('Device State: Top app', 'battery_stats.top');

    this.addSliceTrack(
      ctx, 'Device State: Long wakelocks', `SELECT
            ts - 60000000000 as ts,
            dur + 60000000000 as dur,
            str_value AS name,
            ifnull(
            (select package_name from package_list where uid = int_value % 100000),
            int_value) as package
        FROM android_battery_stats_event_slices
        WHERE track_name = "battery_stats.longwake"`,
      undefined, ['package']);

    query('Device State: Foreground apps', 'battery_stats.fg');
    query('Device State: Jobs', 'battery_stats.job');

    if (features.has('atom.thermal_throttling_severity_state_changed')) {
      this.addSliceTrack(
        ctx, 'Device State: Thermal throttling', THERMAL_THROTTLING);
    }
  }

  async addNetworkSummary(ctx: PluginContextTrace, features: Set<string>):
      Promise<void> {
    if (!features.has('net.modem') && !features.has('net.wifi')) {
      return;
    }

    const groupName = 'Network Summary';

    const e = ctx.engine;
    await e.query(NETWORK_SUMMARY);

    this.addSliceTrack(ctx, 'Default network', DEFAULT_NETWORK, groupName);

    if (features.has('atom.network_tethering_reported')) {
      this.addSliceTrack(ctx, 'Tethering', TETHERING, groupName);
    }
    if (features.has('net.wifi')) {
      this.addCounterTrack(
        ctx, 'Wifi bytes (logscale)',
        `select ts, ifnull(ln(sum(value)), 0) as value from network_summary where dev_type = 'wifi' group by 1`,
        groupName);
      this.addCounterTrack(
        ctx, 'Wifi TX bytes (logscale)',
        `select ts, ifnull(ln(value), 0) as value from network_summary where dev_type = 'wifi' and dir = 'tx'`,
        groupName);
      this.addCounterTrack(
        ctx, 'Wifi RX bytes (logscale)',
        `select ts, ifnull(ln(value), 0) as value from network_summary where dev_type = 'wifi' and dir = 'rx'`,
        groupName);
    }
    if (features.has('net.modem')) {
      this.addCounterTrack(
        ctx, 'Modem bytes (logscale)',
        `select ts, ifnull(ln(sum(value)), 0) as value from network_summary where dev_type = 'modem' group by 1`,
        groupName);
      this.addCounterTrack(
        ctx, 'Modem TX bytes (logscale)',
        `select ts, ifnull(ln(value), 0) as value from network_summary where dev_type = 'modem' and dir = 'tx'`,
        groupName);
      this.addCounterTrack(
        ctx, 'Modem RX bytes (logscale)',
        `select ts, ifnull(ln(value), 0) as value from network_summary where dev_type = 'modem' and dir = 'rx'`,
        groupName);
    }
    this.addBatteryStatsState(
      ctx, 'Cellular interface', 'battery_stats.mobile_radio', groupName,
      features);
    this.addBatteryStatsState(
      ctx, 'Cellular connection', 'battery_stats.data_conn', groupName,
      features);
    this.addBatteryStatsState(
      ctx, 'Cellular strength', 'battery_stats.phone_signal_strength',
      groupName, features);
    this.addBatteryStatsState(
      ctx, 'Wifi interface', 'battery_stats.wifi_radio', groupName, features);
    this.addBatteryStatsState(
      ctx, 'Wifi supplicant state', 'battery_stats.wifi_suppl', groupName,
      features);
    this.addBatteryStatsState(
      ctx, 'Wifi strength', 'battery_stats.wifi_signal_strength', groupName,
      features);
  }

  async addModemDetail(ctx: PluginContextTrace, features: Set<string>):
      Promise<void> {
    if (!features.has('atom.modem_activity_info')) {
      return;
    }
    const groupName = 'Modem Detail';
    await this.addModemActivityInfo(ctx, groupName);
    if (features.has('track.ril')) {
      await this.addModemRil(ctx, groupName);
    }
  }

  async addModemActivityInfo(ctx: PluginContextTrace, groupName: string):
      Promise<void> {
    const query = (name: string, col: string): void =>
      this.addCounterTrack(
        ctx,
        name,
        `select ts, ${col}_ratio as value from modem_activity_info`,
        groupName);

    await ctx.engine.query(MODEM_ACTIVITY_INFO);
    query('Modem sleep', 'sleep_time');
    query('Modem controller idle', 'controller_idle_time');
    query('Modem RX time', 'controller_rx_time');
    query('Modem TX time power 0', 'controller_tx_time_pl0');
    query('Modem TX time power 1', 'controller_tx_time_pl1');
    query('Modem TX time power 2', 'controller_tx_time_pl2');
    query('Modem TX time power 3', 'controller_tx_time_pl3');
    query('Modem TX time power 4', 'controller_tx_time_pl4');
  }

  async addModemRil(ctx: PluginContextTrace, groupName: string): Promise<void> {
    const rilStrength =
        (band: string, value: string): void =>
          this.addSliceTrack(
            ctx,
            `Modem signal strength ${band} ${value}`,
            `SELECT ts, dur, name FROM RilScreenOn WHERE band_name = '${
              band}' AND value_name = '${value}'`,
            groupName);

    const e = ctx.engine;
    await e.query(MODEM_RIL_STRENGTH);
    await e.query(MODEM_RIL_CHANNELS_PREAMBLE);

    rilStrength('LTE', 'rsrp');
    rilStrength('LTE', 'rssi');
    rilStrength('NR', 'rsrp');
    rilStrength('NR', 'rssi');

    this.addSliceTrack(
      ctx, 'Modem channel config', MODEM_RIL_CHANNELS, groupName);

    this.addSliceTrack(
      ctx, 'Modem cell reselection', MODEM_CELL_RESELECTION, groupName,
      ['raw_ril']);
  }

  async addKernelWakelocks(ctx: PluginContextTrace, features: Set<string>):
      Promise<void> {
    if (!features.has('atom.kernel_wakelock')) {
      return;
    }
    const groupName = 'Kernel Wakelock Summary';

    const e = ctx.engine;
    await e.query(`INCLUDE PERFETTO MODULE android.suspend;`);
    await e.query(KERNEL_WAKELOCKS);
    const result = await e.query(KERNEL_WAKELOCKS_SUMMARY);
    const it = result.iter({wakelock_name: 'str'});
    for (; it.valid(); it.next()) {
      this.addSliceTrack(
        ctx,
        it.wakelock_name,
        `select ts, dur, name from kernel_wakelocks where wakelock_name = "${
          it.wakelock_name}"`,
        groupName);
    }
  }

  async addWakeups(ctx: PluginContextTrace, features: Set<string>):
      Promise<void> {
    if (!features.has('track.suspend_backoff')) {
      return;
    }

    const e = ctx.engine;
    const groupName = 'Wakeups';
    await e.query(`INCLUDE PERFETTO MODULE android.suspend;`);
    await e.query(WAKEUPS);
    const result = await e.query(`select
          item,
          sum(dur) as sum_dur
      from wakeups
      group by 1
      having sum_dur > 600e9`);
    const it = result.iter({item: 'str'});
    const sqlPrefix = `select
                ts,
                dur,
                item || case backoff_reason
                  when 'short' then ' (Short suspend backoff)'
                  when 'failed' then ' (Failed suspend backoff)'
                  else ''
                end as name,
                item,
                type,
                raw_wakeup,
                attribution,
                suspend_quality,
                backoff_state,
                backoff_reason,
                backoff_count,
                backoff_millis
            from wakeups`;
    const items = [];
    let labelOther = false;
    for (; it.valid(); it.next()) {
      labelOther = true;
      this.addSliceTrack(
        ctx,
        `Wakeup ${it.item}`,
        `${sqlPrefix} where item="${it.item}"`,
        groupName,
        WAKEUPS_COLUMNS);
      items.push(it.item);
    }
    this.addSliceTrack(
      ctx, labelOther ? 'Other wakeups' : 'Wakeups',
      `${sqlPrefix} where item not in ('${items.join('\',\'')}')`, groupName,
      WAKEUPS_COLUMNS);
  }

  async addHighCpu(ctx: PluginContextTrace, features: Set<string>):
      Promise<void> {
    if (!features.has('atom.cpu_cycles_per_uid_cluster')) {
      return;
    }
    const groupName = 'CPU per UID (major users)';

    const e = ctx.engine;

    await e.query(HIGH_CPU);
    const result = await e.query(
      `select distinct pkg, cluster from high_cpu where value > 10 order by 1, 2`);
    const it = result.iter({pkg: 'str', cluster: 'str'});
    for (; it.valid(); it.next()) {
      this.addCounterTrack(
        ctx,
        `CPU (${it.cluster}): ${it.pkg}`,
        `select ts, value from high_cpu where pkg = "${
          it.pkg}" and cluster="${it.cluster}"`,
        groupName);
    }
  }

  async addBluetooth(ctx: PluginContextTrace, features: Set<string>):
      Promise<void> {
    if (!Array.from(features.values())
      .some(
        (f) => f.startsWith('atom.bluetooth_') ||
                     f.startsWith('atom.ble_'))) {
      return;
    }
    const groupName = 'Bluetooth';
    this.addSliceTrack(
      ctx, 'BLE Scans (opportunistic)', bleScanQuery('opportunistic'),
      groupName);
    this.addSliceTrack(
      ctx, 'BLE Scans (filtered)', bleScanQuery('filtered'), groupName);
    this.addSliceTrack(
      ctx, 'BLE Scans (unfiltered)', bleScanQuery('not filtered'), groupName);
    this.addSliceTrack(ctx, 'BLE Scan Results', BLE_RESULTS, groupName);
    this.addSliceTrack(ctx, 'Connections (ACL)', BT_CONNS_ACL, groupName);
    this.addSliceTrack(ctx, 'Connections (SCO)', BT_CONNS_SCO, groupName);
    this.addSliceTrack(
      ctx, 'Link-level Events', BT_LINK_LEVEL_EVENTS, groupName,
      BT_LINK_LEVEL_EVENTS_COLUMNS);
    this.addSliceTrack(ctx, 'A2DP Audio', BT_A2DP_AUDIO, groupName);
    this.addSliceTrack(
      ctx, 'Bytes Transferred (L2CAP/RFCOMM)', BT_BYTES, groupName);
    this.addSliceTrack(ctx, 'Activity info', BT_ACTIVITY, groupName);
    this.addSliceTrack(
      ctx, 'Quality reports', BT_QUALITY_REPORTS, groupName,
      BT_QUALITY_REPORTS_COLUMNS);
    this.addSliceTrack(
      ctx, 'RSSI Reports', BT_RSSI_REPORTS, groupName, BT_RSSI_REPORTS_COLUMNS);
    this.addSliceTrack(
      ctx, 'HAL Crashes', BT_HAL_CRASHES, groupName, BT_HAL_CRASHES_COLUMNS);
    this.addSliceTrack(
      ctx, 'Code Path Counter', BT_CODE_PATH_COUNTER, groupName,
      BT_CODE_PATH_COUNTER_COLUMNS);
  }

  async findFeatures(e: EngineProxy): Promise<Set<string>> {
    const features = new Set<string>();

    const addFeatures = async (q: string) => {
      const result = await e.query(q);
      const it = result.iter({feature: 'str'});
      for (; it.valid(); it.next()) {
        features.add(it.feature);
      }
    };

    await addFeatures(`
      select distinct 'atom.' || s.name as feature
      from track t join slice s on t.id = s.track_id
      where t.name = 'Statsd Atoms'`);

    await addFeatures(`
      select distinct
        case when name like '%wlan%' then 'net.wifi'
            when name like '%rmnet%' then 'net.modem'
            else 'net.other'
        end as feature
      from track
      where name like '%Transmitted' or name like '%Received'`);

    await addFeatures(`
      select distinct 'track.' || lower(name) as feature
      from track where name in ('RIL', 'suspend_backoff') or name like 'battery_stats.%'`);

    await addFeatures(`
      select distinct 'track.battery_stats.*' as feature
      from track where name like 'battery_stats.%'`);

    return features;
  }

  async addTracks(ctx: PluginContextTrace): Promise<void> {
    const features: Set<string> = await this.findFeatures(ctx.engine);

    await this.addNetworkSummary(ctx, features),
    await this.addModemDetail(ctx, features);
    await this.addKernelWakelocks(ctx, features);
    await this.addWakeups(ctx, features);
    await this.addDeviceState(ctx, features);
    await this.addHighCpu(ctx, features);
    await this.addBluetooth(ctx, features);
  }

  async onTraceLoad(ctx: PluginContextTrace): Promise<void> {
    await this.addTracks(ctx);
  }
}

export const plugin: PluginDescriptor = {
  pluginId: 'dev.perfetto.AndroidLongBatteryTracing',
  plugin: AndroidLongBatteryTracing,
};