import { Inject, Injectable } from '@nestjs/common';
import { EntityServiceImpl } from './entity-service-impl.service';
import { BaseEntity } from '../entity/base-entity.entity';
import { UserData } from '../../user/entity/user.entity';
import { EntityManager, DataSource } from 'typeorm';
import { ViewMaster } from '../entity/view-master.entity';
// import { SectionMasterService } from './section-master.service';
// import { SectionMaster } from '../entity/section-master.entity';
// import { FieldGroup } from '../entity/field-group.entity';
// import { FieldGroupService } from './field-group.service';
import { ViewMaterRespository } from '../repository/view-master.repository';
import { get } from 'http';
import { ConfigService } from '@nestjs/config';
import axios from 'axios';
import { IMicroserviceClients } from 'src/module/microservice-client/service/microservice-clients';
import { firstValueFrom } from 'rxjs';
@Injectable()
export class ViewMasterService extends EntityServiceImpl {
  constructor(
    // private readonly sectionMasterService: SectionMasterService,
    // private readonly fieldGroupService: FieldGroupService,
    private readonly viewMasterRepoService: ViewMaterRespository,
    private readonly dataSource: DataSource,
    private readonly configService: ConfigService,
    @Inject('MICROSERVICE_CLIENT_FACTORY')
    private readonly factory: IMicroserviceClients,
  ) {
    super();
  }

  async createEntity(
    entityData: ViewMaster,
    loggedInUser: UserData,
    manager?: EntityManager,
  ): Promise<BaseEntity> {
    const entityMaster = await this.entityMasterService.getEntityData(
      entityData.entity_type,
      loggedInUser,
    );
    entityData.parent_id = entityMaster.id;
    entityData.parent_type = entityMaster.entity_type;

    const savedEntity = await super.createEntity(
      entityData,
      loggedInUser,
      manager,
    );

    return savedEntity;
  }

  async updateEntity(
    entityData: ViewMaster,
    loggedInUserData: UserData,
  ): Promise<BaseEntity> {
    const res = await super.updateEntity(entityData, loggedInUserData);
    return res;
  }

  async getEntityJson(
    entityType: string,
    type: string,
    loggedInUser: UserData,
    code?: string,
  ) {
    const res = await this.viewMasterRepoService.getEntityJson(
      entityType,
      type,
      loggedInUser,
      code,
    );

    if (type == 'form') {
      return {
        formLayoutJson: res?.published_form_layout,
        formFieldJson: res?.published_form_fields,
      };
    } else {
      return {
        metaJson: res?.meta_json,
      };
    }
  }

  async getEntityData(
    entityType: string,
    id: number,
    loggedInUserData?: UserData | null,
  ) {
    let getTheme = null as any;

    try {
      const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');

      // Make the GET request with query parameters
      const response = await axios.get<any>(
        `${baseUrl}/school/public/theme_json/${loggedInUserData?.level_id}`,

        {
          headers: {
            'Content-Type': 'application/json',
          },
        },
      );

      getTheme = response.data;
    } catch (error) {
      console.error('Internal Entity API call failed:', error.message);
    }

    const viewMaster = await super.getEntityData(
      entityType,
      id,
      loggedInUserData,
    );

    return {
      ...viewMaster,
      theme_json:
        getTheme && getTheme[0]?.theme_json ? getTheme[0].theme_json : null,
    };
  }

  // DROPDOWN
  async getViewMasterByEntityType(entityType: string, loggedInUser: UserData) {
    return await this.viewMasterRepoService.findByEntityType(
      entityType,
      loggedInUser.enterprise_id,
    );
  }
}