import json
import os
import shutil
import tempfile
from enum import Enum

import numpy as np
import pandas as pd

from shapely.geometry import Point, Polygon, box

import geopandas
import geopandas._compat as compat
from geopandas import GeoDataFrame, GeoSeries, points_from_xy, read_file
from geopandas.array import GeometryArray, GeometryDtype, from_shapely

import pytest
from geopandas.testing import assert_geodataframe_equal, assert_geoseries_equal
from geopandas.tests.util import PACKAGE_DIR, validate_boro_df
from pandas.testing import assert_frame_equal, assert_index_equal, assert_series_equal


@pytest.fixture
def dfs(request):
    s1 = GeoSeries(
        [
            Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]),
            Polygon([(2, 2), (4, 2), (4, 4), (2, 4)]),
        ]
    )
    s2 = GeoSeries(
        [
            Polygon([(1, 1), (3, 1), (3, 3), (1, 3)]),
            Polygon([(3, 3), (5, 3), (5, 5), (3, 5)]),
        ]
    )
    df1 = GeoDataFrame({"col1": [1, 2], "geometry": s1})
    df2 = GeoDataFrame({"col2": [1, 2], "geometry": s2})
    return df1, df2


@pytest.fixture(
    params=["union", "intersection", "difference", "symmetric_difference", "identity"]
)
def how(request):
    return request.param


@pytest.mark.usefixtures("_setup_class_nybb_filename")
class TestDataFrame:
    def setup_method(self):
        N = 10
        # self.nybb_filename attached via _setup_class_nybb_filename
        self.df = read_file(self.nybb_filename)
        # TODO re-write instance variables to be fixtures
        self.tempdir = tempfile.mkdtemp()
        self.crs = "epsg:4326"
        self.df2 = GeoDataFrame(
            [
                {"geometry": Point(x, y), "value1": x + y, "value2": x * y}
                for x, y in zip(range(N), range(N))
            ],
            crs=self.crs,
        )
        self.df3 = read_file(
            os.path.join(PACKAGE_DIR, "geopandas", "tests", "data", "null_geom.geojson")
        )

    def teardown_method(self):
        shutil.rmtree(self.tempdir)

    def test_df_init(self):
        assert type(self.df2) is GeoDataFrame
        if compat.HAS_PYPROJ:
            assert self.df2.crs == self.crs

    @pytest.mark.skipif(not compat.HAS_PYPROJ, reason="Requires pyproj")
    def test_different_geo_colname(self):
        from pyproj.exceptions import CRSError

        data = {
            "A": range(5),
            "B": range(-5, 0),
            "location": [Point(x, y) for x, y in zip(range(5), range(5))],
        }
        df = GeoDataFrame(data, crs=self.crs, geometry="location")
        locs = GeoSeries(data["location"], crs=self.crs)
        assert_geoseries_equal(df.geometry, locs)
        assert "geometry" not in df
        assert df.geometry.name == "location"
        # internal implementation detail
        assert df._geometry_column_name == "location"

        geom2 = [Point(x, y) for x, y in zip(range(5, 10), range(5))]
        with pytest.raises(CRSError):
            df.set_geometry(geom2, crs="dummy_crs")

    @pytest.mark.filterwarnings("ignore:Geometry is in a geographic CRS")
    def test_geo_getitem(self):
        data = {
            "A": range(5),
            "B": range(-5, 0),
            "location": [Point(x, y) for x, y in zip(range(5), range(5))],
        }
        df = GeoDataFrame(data, crs=self.crs, geometry="location")
        assert isinstance(df.geometry, GeoSeries)
        df["geometry"] = df["A"]
        assert isinstance(df.geometry, GeoSeries)
        assert df.geometry[0] == data["location"][0]
        # good if this changed in the future
        assert not isinstance(df["geometry"], GeoSeries)
        assert isinstance(df["location"], GeoSeries)

        df["buff"] = df.buffer(1)
        assert isinstance(df["buff"], GeoSeries)

        df["array"] = from_shapely([Point(x, y) for x, y in zip(range(5), range(5))])
        assert isinstance(df["array"], GeoSeries)

        data["geometry"] = [Point(x + 1, y - 1) for x, y in zip(range(5), range(5))]
        df = GeoDataFrame(data, crs=self.crs)
        assert isinstance(df.geometry, GeoSeries)
        assert isinstance(df["geometry"], GeoSeries)
        # good if this changed in the future
        assert not isinstance(df["location"], GeoSeries)

    def test_getitem_no_geometry(self):
        res = self.df2[["value1", "value2"]]
        assert isinstance(res, pd.DataFrame)
        assert not isinstance(res, GeoDataFrame)

        # with different name
        df = self.df2.copy()
        df = df.rename(columns={"geometry": "geom"}).set_geometry("geom")
        assert isinstance(df, GeoDataFrame)
        res = df[["value1", "value2"]]
        assert isinstance(res, pd.DataFrame)
        assert not isinstance(res, GeoDataFrame)

        df["geometry"] = np.arange(len(df))
        res = df[["value1", "value2", "geometry"]]
        assert isinstance(res, pd.DataFrame)
        assert not isinstance(res, GeoDataFrame)

    def test_geo_setitem(self):
        data = {
            "A": range(5),
            "B": np.arange(5.0),
            "geometry": [Point(x, y) for x, y in zip(range(5), range(5))],
        }
        df = GeoDataFrame(data)
        s = GeoSeries([Point(x, y + 1) for x, y in zip(range(5), range(5))])

        # setting geometry column
        for vals in [s, s.values]:
            df["geometry"] = vals
            assert_geoseries_equal(df["geometry"], s)
            assert_geoseries_equal(df.geometry, s)

        # non-aligned values
        s2 = GeoSeries([Point(x, y + 1) for x, y in zip(range(6), range(6))])
        df["geometry"] = s2
        assert_geoseries_equal(df["geometry"], s)
        assert_geoseries_equal(df.geometry, s)

        # setting other column with geometry values -> preserve geometry type
        for vals in [s, s.values]:
            df["other_geom"] = vals
            assert isinstance(df["other_geom"].values, GeometryArray)

        # overwriting existing non-geometry column -> preserve geometry type
        data = {
            "A": range(5),
            "B": np.arange(5.0),
            "other_geom": range(5),
            "geometry": [Point(x, y) for x, y in zip(range(5), range(5))],
        }
        df = GeoDataFrame(data)
        for vals in [s, s.values]:
            df["other_geom"] = vals
            assert isinstance(df["other_geom"].values, GeometryArray)

    def test_geometry_property(self):
        assert_geoseries_equal(
            self.df.geometry,
            self.df["geometry"],
            check_dtype=True,
            check_index_type=True,
        )

        df = self.df.copy()
        new_geom = [
            Point(x, y) for x, y in zip(range(len(self.df)), range(len(self.df)))
        ]
        df.geometry = new_geom

        new_geom = GeoSeries(new_geom, index=df.index, crs=df.crs)
        assert_geoseries_equal(df.geometry, new_geom)
        assert_geoseries_equal(df["geometry"], new_geom)

        if compat.HAS_PYPROJ:
            # new crs
            gs = new_geom.to_crs(crs="epsg:3857")
            df.geometry = gs
            assert df.crs == "epsg:3857"

    def test_geometry_property_errors(self):
        with pytest.raises(AttributeError):
            df = self.df.copy()
            del df["geometry"]
            df.geometry

        # list-like error
        with pytest.raises(ValueError):
            df = self.df2.copy()
            df.geometry = "value1"

        # list-like error
        with pytest.raises(ValueError):
            df = self.df.copy()
            df.geometry = "apple"

        # non-geometry error
        with pytest.raises(TypeError):
            df = self.df.copy()
            df.geometry = list(range(df.shape[0]))

        with pytest.raises(KeyError):
            df = self.df.copy()
            del df["geometry"]
            df["geometry"]

        # ndim error
        with pytest.raises(ValueError):
            df = self.df.copy()
            df.geometry = df

    def test_rename_geometry(self):
        assert self.df.geometry.name == "geometry"
        df2 = self.df.rename_geometry("new_name")
        assert df2.geometry.name == "new_name"
        df2 = self.df.rename_geometry("new_name", inplace=True)
        assert df2 is None
        assert self.df.geometry.name == "new_name"

        # existing column error
        msg = "Column named Shape_Area already exists"
        with pytest.raises(ValueError, match=msg):
            df2 = self.df.rename_geometry("Shape_Area")
        with pytest.raises(ValueError, match=msg):
            self.df.rename_geometry("Shape_Area", inplace=True)

    def test_set_geometry(self):
        geom = GeoSeries([Point(x, y) for x, y in zip(range(5), range(5))])
        original_geom = self.df.geometry

        df2 = self.df.set_geometry(geom)
        assert self.df is not df2
        assert_geoseries_equal(df2.geometry, geom, check_crs=False)
        assert_geoseries_equal(self.df.geometry, original_geom)
        assert_geoseries_equal(self.df["geometry"], self.df.geometry)
        # unknown column
        with pytest.raises(ValueError):
            self.df.set_geometry("nonexistent-column")

        # ndim error
        with pytest.raises(ValueError):
            self.df.set_geometry(self.df)

    @pytest.mark.skipif(not compat.HAS_PYPROJ, reason="Requires pyproj")
    def test_set_geometry_crs(self):
        geom = GeoSeries([Point(x, y) for x, y in zip(range(5), range(5))])

        # new crs - setting should default to GeoSeries' crs
        gs = GeoSeries(geom, crs="epsg:3857")
        new_df = self.df.set_geometry(gs)
        assert new_df.crs == "epsg:3857"

        # explicit crs overrides self and dataframe
        new_df = self.df.set_geometry(gs, crs="epsg:26909")
        assert new_df.crs == "epsg:26909"
        assert new_df.geometry.crs == "epsg:26909"

        # Series should use dataframe's
        new_df = self.df.set_geometry(geom.values)
        assert new_df.crs == self.df.crs
        assert new_df.geometry.crs == self.df.crs

    def test_set_geometry_col(self):
        g = self.df.geometry
        g_simplified = g.simplify(100)
        self.df["simplified_geometry"] = g_simplified
        df2 = self.df.set_geometry("simplified_geometry")

        # Drop is false by default
        assert "simplified_geometry" in df2
        assert_geoseries_equal(df2.geometry, g_simplified)

        # If True, drops column and renames to geometry
        with pytest.warns(FutureWarning):
            df3 = self.df.set_geometry("simplified_geometry", drop=True)
        assert "simplified_geometry" not in df3
        assert_geoseries_equal(df3.geometry, g_simplified)

    def test_set_geometry_inplace(self):
        geom = [Point(x, y) for x, y in zip(range(5), range(5))]
        ret = self.df.set_geometry(geom, inplace=True)
        assert ret is None
        geom = GeoSeries(geom, index=self.df.index, crs=self.df.crs)
        assert_geoseries_equal(self.df.geometry, geom)

    def test_set_geometry_series(self):
        # Test when setting geometry with a Series that
        # alignment will occur
        #
        # Reverse the index order
        # Set the Series to be Point(i,i) where i is the index
        self.df.index = range(len(self.df) - 1, -1, -1)

        d = {}
        for i in range(len(self.df)):
            d[i] = Point(i, i)
        g = GeoSeries(d)
        # At this point, the DataFrame index is [4,3,2,1,0] and the
        # GeoSeries index is [0,1,2,3,4]. Make sure set_geometry aligns
        # them to match indexes
        df = self.df.set_geometry(g)

        for i, r in df.iterrows():
            assert i == r["geometry"].x
            assert i == r["geometry"].y

    def test_set_geometry_empty(self):
        df = pd.DataFrame(columns=["a", "geometry"], index=pd.DatetimeIndex([]))
        result = df.set_geometry("geometry")
        assert isinstance(result, GeoDataFrame)
        assert isinstance(result.index, pd.DatetimeIndex)

    def test_set_geometry_np_int(self):
        self.df.loc[:, 0] = self.df.geometry
        df = self.df.set_geometry(np.int64(0))
        assert df.geometry.name == 0

    def test_get_geometry_invalid(self):
        df = GeoDataFrame()
        # no column "geometry" ever added
        df["geom"] = self.df.geometry
        msg_geo_col_none = "active geometry column to use has not been set. "

        with pytest.raises(AttributeError, match=msg_geo_col_none):
            df.geometry
        # "geometry" originally present but dropped (but still a gdf)
        col_subset_drop_geometry = ["BoroCode", "BoroName", "geom2"]
        df2 = self.df.copy().assign(geom2=self.df.geometry)[col_subset_drop_geometry]
        with pytest.raises(AttributeError, match="is not present."):
            df2.geometry

        msg_other_geo_cols_present = "There are columns with geometry data type"
        msg_no_other_geo_cols = "There are no existing columns with geometry data type"
        with pytest.raises(AttributeError, match=msg_other_geo_cols_present):
            df2.geometry

        with pytest.raises(AttributeError, match=msg_no_other_geo_cols):
            GeoDataFrame().geometry

    def test_get_geometry_geometry_inactive(self):
        # https://github.com/geopandas/geopandas/issues/2574
        df = self.df.assign(geom2=self.df.geometry).set_geometry("geom2")
        df = df.loc[:, ["BoroName", "geometry"]]
        assert df._geometry_column_name == "geom2"
        msg_geo_col_missing = "is not present. "
        # Check that df.geometry raises if active geometry column is missing,
        # it should not fall back to column named "geometry"
        with pytest.raises(AttributeError, match=msg_geo_col_missing):
            df.geometry

    @pytest.mark.skipif(not compat.HAS_PYPROJ, reason="Requires pyproj")
    def test_override_existing_crs_warning(self):
        with pytest.warns(
            DeprecationWarning,
            match="Overriding the CRS of a GeoSeries that already has CRS",
        ):
            self.df.geometry.crs = "epsg:2100"

        with pytest.warns(
            DeprecationWarning,
            match="Overriding the CRS of a GeoDataFrame that already has CRS",
        ):
            self.df.crs = "epsg:4326"

    def test_active_geometry_name(self):
        # default single active called "geometry"
        assert self.df.active_geometry_name == "geometry"

        # one GeoSeries, not active
        no_active = GeoDataFrame({"foo": self.df.BoroName, "bar": self.df.geometry})
        assert no_active.active_geometry_name is None
        assert no_active.set_geometry("bar").active_geometry_name == "bar"

        # multiple, none active
        multiple = GeoDataFrame({"foo": self.df.geometry, "bar": self.df.geometry})
        assert multiple.active_geometry_name is None
        assert multiple.set_geometry("foo").active_geometry_name == "foo"
        assert multiple.set_geometry("bar").active_geometry_name == "bar"

    def test_align(self):
        df = self.df2

        res1, res2 = df.align(df)
        assert_geodataframe_equal(res1, df)
        assert_geodataframe_equal(res2, df)

        res1, res2 = df.align(df.copy())
        assert_geodataframe_equal(res1, df)
        assert_geodataframe_equal(res2, df)

        if compat.HAS_PYPROJ:
            # assert crs is / is not preserved on mixed dataframes
            df_nocrs = df.copy().set_crs(None, allow_override=True)
            res1, res2 = df.align(df_nocrs)
            assert_geodataframe_equal(res1, df)
            assert res1.crs is not None
            assert_geodataframe_equal(res2, df_nocrs)
            assert res2.crs is None

        # mixed GeoDataFrame / DataFrame
        df_nogeom = pd.DataFrame(df.drop("geometry", axis=1))
        res1, res2 = df.align(df_nogeom, axis=0)
        assert_geodataframe_equal(res1, df)
        assert type(res2) is pd.DataFrame
        assert_frame_equal(res2, df_nogeom)

        # same as above but now with actual alignment
        df1 = df.iloc[1:].copy()
        df2 = df.iloc[:-1].copy()

        exp1 = df.copy()
        exp1.iloc[0] = np.nan
        exp2 = df.copy()
        exp2.iloc[-1] = np.nan
        res1, res2 = df1.align(df2)
        assert_geodataframe_equal(res1, exp1)
        assert_geodataframe_equal(res2, exp2)

        if compat.HAS_PYPROJ:
            df2_nocrs = df2.copy().set_crs(None, allow_override=True)
            exp2_nocrs = exp2.copy().set_crs(None, allow_override=True)
            res1, res2 = df1.align(df2_nocrs)
            assert_geodataframe_equal(res1, exp1)
            assert res1.crs is not None
            assert_geodataframe_equal(res2, exp2_nocrs)
            assert res2.crs is None

        df2_nogeom = pd.DataFrame(df2.drop("geometry", axis=1))
        exp2_nogeom = pd.DataFrame(exp2.drop("geometry", axis=1))
        res1, res2 = df1.align(df2_nogeom, axis=0)
        assert_geodataframe_equal(res1, exp1)
        assert type(res2) is pd.DataFrame
        assert_frame_equal(res2, exp2_nogeom)

    @pytest.mark.skipif(not compat.HAS_PYPROJ, reason="Requires pyproj")
    def test_to_json(self):
        text = self.df.to_json(to_wgs84=True)
        data = json.loads(text)
        assert data["type"] == "FeatureCollection"
        assert len(data["features"]) == 5
        assert "id" in data["features"][0].keys()

        # check it converts to WGS84
        coord = data["features"][0]["geometry"]["coordinates"][0][0][0]
        np.testing.assert_allclose(coord, [-74.0505080640324, 40.5664220341941])

    def test_to_json_wgs84_false(self):
        text = self.df.to_json()
        data = json.loads(text)
        # check it doesn't convert to WGS84
        coord = data["features"][0]["geometry"]["coordinates"][0][0][0]
        assert coord == [970217.0223999023, 145643.33221435547]

    def test_to_json_no_crs(self):
        self.df.geometry.array.crs = None
        with pytest.raises(ValueError, match="CRS is not set"):
            self.df.to_json(to_wgs84=True)

    @pytest.mark.filterwarnings(
        "ignore:Geometry column does not contain geometry:UserWarning"
    )
    def test_to_json_geom_col(self):
        df = self.df.copy()
        df["geom"] = df["geometry"]
        df["geometry"] = np.arange(len(df))
        df.set_geometry("geom", inplace=True)

        text = df.to_json()
        data = json.loads(text)
        assert data["type"] == "FeatureCollection"
        assert len(data["features"]) == 5

    def test_to_json_only_geom_column(self):
        text = self.df[["geometry"]].to_json()
        data = json.loads(text)
        assert len(data["features"]) == 5
        assert "id" in data["features"][0].keys()

    def test_to_json_na(self):
        # Set a value as nan and make sure it's written
        self.df.loc[self.df["BoroName"] == "Queens", "Shape_Area"] = np.nan

        text = self.df.to_json()
        data = json.loads(text)
        assert len(data["features"]) == 5
        for f in data["features"]:
            props = f["properties"]
            assert len(props) == 4
            if props["BoroName"] == "Queens":
                assert props["Shape_Area"] is None

    def test_to_json_bad_na(self):
        # Check that a bad na argument raises error
        with pytest.raises(ValueError):
            self.df.to_json(na="garbage")

    def test_to_json_dropna(self):
        self.df.loc[self.df["BoroName"] == "Queens", "Shape_Area"] = np.nan
        self.df.loc[self.df["BoroName"] == "Bronx", "Shape_Leng"] = np.nan

        text = self.df.to_json(na="drop")
        data = json.loads(text)
        assert len(data["features"]) == 5
        for f in data["features"]:
            props = f["properties"]
            if props["BoroName"] == "Queens":
                assert len(props) == 3
                assert "Shape_Area" not in props
                # Just make sure setting it to nan in a different row
                # doesn't affect this one
                assert "Shape_Leng" in props
            elif props["BoroName"] == "Bronx":
                assert len(props) == 3
                assert "Shape_Leng" not in props
                assert "Shape_Area" in props
            else:
                assert len(props) == 4

    def test_to_json_keepna(self):
        self.df.loc[self.df["BoroName"] == "Queens", "Shape_Area"] = np.nan
        self.df.loc[self.df["BoroName"] == "Bronx", "Shape_Leng"] = np.nan

        text = self.df.to_json(na="keep")
        data = json.loads(text)
        assert len(data["features"]) == 5
        for f in data["features"]:
            props = f["properties"]
            assert len(props) == 4
            if props["BoroName"] == "Queens":
                assert np.isnan(props["Shape_Area"])
                # Just make sure setting it to nan in a different row
                # doesn't affect this one
                assert "Shape_Leng" in props
            elif props["BoroName"] == "Bronx":
                assert np.isnan(props["Shape_Leng"])
                assert "Shape_Area" in props

    def test_to_json_drop_id(self):
        text = self.df.to_json(drop_id=True)
        data = json.loads(text)
        assert len(data["features"]) == 5
        for f in data["features"]:
            assert "id" not in f.keys()

    def test_to_json_drop_id_only_geom_column(self):
        text = self.df[["geometry"]].to_json(drop_id=True)
        data = json.loads(text)
        assert len(data["features"]) == 5
        for f in data["features"]:
            assert "id" not in f.keys()

    def test_to_json_with_duplicate_columns(self):
        df = GeoDataFrame(
            data=[[1, 2, 3]], columns=["a", "b", "a"], geometry=[Point(1, 1)]
        )
        with pytest.raises(
            ValueError, match="GeoDataFrame cannot contain duplicated column names."
        ):
            df.to_json()

    def test_copy(self):
        df2 = self.df.copy()
        assert type(df2) is GeoDataFrame
        assert self.df.crs == df2.crs

    def test_empty_copy(self):
        # https://github.com/geopandas/geopandas/issues/2765
        df = GeoDataFrame()
        df2 = df.copy()
        assert type(df2) is GeoDataFrame
        df3 = df.copy(deep=True)
        assert type(df3) is GeoDataFrame

    def test_no_geom_copy(self):
        df = GeoDataFrame(pd.DataFrame({"a": [1, 2, 3]}))
        assert type(df) is GeoDataFrame
        assert type(df.copy()) is GeoDataFrame

    def test_empty(self):
        df = GeoDataFrame({"geometry": []})
        assert df.geometry.dtype == "geometry"
        df = GeoDataFrame({"a": []}, geometry="a")
        assert df.geometry.dtype == "geometry"
        df = GeoDataFrame(geometry=[])
        assert df.geometry.dtype == "geometry"

    def test_bool_index(self):
        # Find boros with 'B' in their name
        df = self.df[self.df["BoroName"].str.contains("B")]
        assert len(df) == 2
        boros = df["BoroName"].values
        assert "Brooklyn" in boros
        assert "Bronx" in boros
        assert type(df) is GeoDataFrame

    def test_coord_slice_points(self):
        assert self.df2.cx[-2:-1, -2:-1].empty
        assert_frame_equal(self.df2, self.df2.cx[:, :])
        assert_frame_equal(self.df2.loc[5:], self.df2.cx[5:, :])
        assert_frame_equal(self.df2.loc[5:], self.df2.cx[:, 5:])
        assert_frame_equal(self.df2.loc[5:], self.df2.cx[5:, 5:])

    def test_from_dict(self):
        data = {"A": [1], "geometry": [Point(0.0, 0.0)]}
        df = GeoDataFrame.from_dict(data, crs=3857)
        if compat.HAS_PYPROJ:
            assert df.crs == "epsg:3857"
        else:
            assert df.crs is None
        assert df._geometry_column_name == "geometry"

        data = {"B": [1], "location": [Point(0.0, 0.0)]}
        df = GeoDataFrame.from_dict(data, geometry="location")
        assert df._geometry_column_name == "location"

    def test_from_features(self, nybb_filename):
        fiona = pytest.importorskip("fiona")
        with fiona.open(nybb_filename) as f:
            features = list(f)
            crs = f.crs_wkt

        df = GeoDataFrame.from_features(features, crs=crs)
        validate_boro_df(df, case_sensitive=True)
        if compat.HAS_PYPROJ:
            assert df.crs == crs
        else:
            assert df.crs is None

    def test_from_features_unaligned_properties(self):
        p1 = Point(1, 1)
        f1 = {
            "type": "Feature",
            "properties": {"a": 0},
            "geometry": p1.__geo_interface__,
        }

        p2 = Point(2, 2)
        f2 = {
            "type": "Feature",
            "properties": {"b": 1},
            "geometry": p2.__geo_interface__,
        }

        p3 = Point(3, 3)
        f3 = {
            "type": "Feature",
            "properties": None,
            "geometry": p3.__geo_interface__,
        }

        df = GeoDataFrame.from_features([f1, f2, f3])

        result = df[["a", "b"]]
        expected = pd.DataFrame.from_dict(
            [{"a": 0, "b": np.nan}, {"a": np.nan, "b": 1}, {"a": np.nan, "b": np.nan}]
        )
        assert_frame_equal(expected, result)

    def test_from_features_empty_properties(self):
        geojson_properties_object = """{
          "type": "FeatureCollection",
          "features": [
            {
              "type": "Feature",
              "properties": {},
              "geometry": {
                "type": "Polygon",
                "coordinates": [
                  [
                    [
                      11.3456529378891,
                      46.49461446367692
                    ],
                    [
                      11.345674395561216,
                      46.494097442978195
                    ],
                    [
                      11.346918940544128,
                      46.49385370294394
                    ],
                    [
                      11.347616314888,
                      46.4938352377453
                    ],
                    [
                      11.347514390945435,
                      46.49466985846028
                    ],
                    [
                      11.3456529378891,
                      46.49461446367692
                    ]
                  ]
                ]
              }
            }
          ]
        }"""

        geojson_properties_null = """{
          "type": "FeatureCollection",
          "features": [
            {
              "type": "Feature",
              "properties": null,
              "geometry": {
                "type": "Polygon",
                "coordinates": [
                  [
                    [
                      11.3456529378891,
                      46.49461446367692
                    ],
                    [
                      11.345674395561216,
                      46.494097442978195
                    ],
                    [
                      11.346918940544128,
                      46.49385370294394
                    ],
                    [
                      11.347616314888,
                      46.4938352377453
                    ],
                    [
                      11.347514390945435,
                      46.49466985846028
                    ],
                    [
                      11.3456529378891,
                      46.49461446367692
                    ]
                  ]
                ]
              }
            }
          ]
        }"""

        # geoJSON with empty properties
        gjson_po = json.loads(geojson_properties_object)
        gdf1 = GeoDataFrame.from_features(gjson_po)

        # geoJSON with null properties
        gjson_null = json.loads(geojson_properties_null)
        gdf2 = GeoDataFrame.from_features(gjson_null)

        assert_frame_equal(gdf1, gdf2)

    def test_from_features_geom_interface_feature(self):
        class Placemark:
            def __init__(self, geom, val):
                self.__geo_interface__ = {
                    "type": "Feature",
                    "properties": {"a": val},
                    "geometry": geom.__geo_interface__,
                }

        p1 = Point(1, 1)
        f1 = Placemark(p1, 0)
        p2 = Point(3, 3)
        f2 = Placemark(p2, 0)
        df = GeoDataFrame.from_features([f1, f2])
        assert sorted(df.columns) == ["a", "geometry"]
        assert df.geometry.tolist() == [p1, p2]

    def test_from_feature_collection(self):
        data = {
            "name": ["a", "b", "c"],
            "lat": [45, 46, 47.5],
            "lon": [-120, -121.2, -122.9],
        }

        df = pd.DataFrame(data)
        geometry = [Point(xy) for xy in zip(df["lon"], df["lat"])]
        gdf = GeoDataFrame(df, geometry=geometry)
        # from_features returns sorted columns
        expected = gdf[["geometry", "name", "lat", "lon"]]

        # test FeatureCollection
        res = GeoDataFrame.from_features(gdf.__geo_interface__)
        assert_frame_equal(res, expected)

        # test list of Features
        res = GeoDataFrame.from_features(gdf.__geo_interface__["features"])
        assert_frame_equal(res, expected)

        # test __geo_interface__ attribute (a GeoDataFrame has one)
        res = GeoDataFrame.from_features(gdf)
        assert_frame_equal(res, expected)

    def test_dataframe_to_geodataframe(self):
        df = pd.DataFrame(
            {"A": range(len(self.df)), "location": np.array(self.df.geometry)},
            index=self.df.index,
        )
        gf = df.set_geometry("location", crs=self.df.crs)
        assert isinstance(df, pd.DataFrame)
        assert isinstance(gf, GeoDataFrame)
        assert_geoseries_equal(gf.geometry, self.df.geometry)
        assert gf.geometry.name == "location"
        assert "geometry" not in gf

        with pytest.warns(FutureWarning):
            gf2 = df.set_geometry("location", crs=self.df.crs, drop=True)
        assert isinstance(df, pd.DataFrame)
        assert isinstance(gf2, GeoDataFrame)
        assert gf2.geometry.name == "geometry"
        assert "geometry" in gf2
        assert "location" not in gf2
        assert "location" in df

        # should be a copy
        df.loc[0, "A"] = 100
        assert gf.loc[0, "A"] == 0
        assert gf2.loc[0, "A"] == 0

        with pytest.raises(ValueError):
            df.set_geometry("location", inplace=True)

    def test_dataframe_not_manipulated(self):
        df = pd.DataFrame(
            {
                "A": range(len(self.df)),
                "latitude": self.df.geometry.centroid.y,
                "longitude": self.df.geometry.centroid.x,
            },
            index=self.df.index,
        )
        df_copy = df.copy()
        gf = GeoDataFrame(
            df,
            geometry=points_from_xy(df["longitude"], df["latitude"]),
            crs=self.df.crs,
        )
        assert type(df) is pd.DataFrame
        assert "geometry" not in df
        assert_frame_equal(df, df_copy)
        assert isinstance(gf, GeoDataFrame)
        assert hasattr(gf, "geometry")

        # ensure mutating columns in gf doesn't update df
        gf.loc[0, "A"] = 7
        assert_frame_equal(df, df_copy)
        gf["A"] = 3
        assert_frame_equal(df, df_copy)

    def test_geodataframe_geointerface(self):
        assert self.df.__geo_interface__["type"] == "FeatureCollection"
        assert len(self.df.__geo_interface__["features"]) == self.df.shape[0]

    def test_geodataframe_iterfeatures(self):
        df = self.df.iloc[:1].copy()
        df.loc[0, "BoroName"] = np.nan
        # when containing missing values
        # null: output the missing entries as JSON null
        result = next(iter(df.iterfeatures(na="null")))["properties"]
        assert result["BoroName"] is None
        # drop: remove the property from the feature.
        result = next(iter(df.iterfeatures(na="drop")))["properties"]
        assert "BoroName" not in result.keys()
        # keep: output the missing entries as NaN
        result = next(iter(df.iterfeatures(na="keep")))["properties"]
        assert np.isnan(result["BoroName"])

        # test for checking that the (non-null) features are python scalars and
        # not numpy scalars
        assert type(df.loc[0, "Shape_Leng"]) is np.float64
        # null
        result = next(iter(df.iterfeatures(na="null")))
        assert isinstance(result["properties"]["Shape_Leng"], float)
        # drop
        result = next(iter(df.iterfeatures(na="drop")))
        assert isinstance(result["properties"]["Shape_Leng"], float)
        # keep
        result = next(iter(df.iterfeatures(na="keep")))
        assert isinstance(result["properties"]["Shape_Leng"], float)

        # when only having numerical columns
        df_only_numerical_cols = df[["Shape_Leng", "Shape_Area", "geometry"]]
        assert type(df_only_numerical_cols.loc[0, "Shape_Leng"]) is np.float64
        # null
        result = next(iter(df_only_numerical_cols.iterfeatures(na="null")))
        assert isinstance(result["properties"]["Shape_Leng"], float)
        # drop
        result = next(iter(df_only_numerical_cols.iterfeatures(na="drop")))
        assert isinstance(result["properties"]["Shape_Leng"], float)
        # keep
        result = next(iter(df_only_numerical_cols.iterfeatures(na="keep")))
        assert isinstance(result["properties"]["Shape_Leng"], float)

        with pytest.raises(
            ValueError, match="GeoDataFrame cannot contain duplicated column names."
        ):
            df_with_duplicate_columns = df[
                ["Shape_Leng", "Shape_Leng", "Shape_Area", "geometry"]
            ]
            list(df_with_duplicate_columns.iterfeatures())

        # geometry not set
        df = GeoDataFrame({"values": [0, 1], "geom": [Point(0, 1), Point(1, 0)]})
        with pytest.raises(AttributeError):
            list(df.iterfeatures())

    def test_geodataframe_iterfeatures_non_scalars(self):
        # When some features in geodataframe are non-scalar values
        df = GeoDataFrame(
            {"geometry": [Point(1, 2)], "non-scalar": [[1, 2]], "test_col": None}
        )
        # null
        expected = {"non-scalar": [1, 2], "test_col": None}
        result = next(iter(df.iterfeatures(na="null"))).get("properties")
        assert expected == result
        # drop
        expected = {"non-scalar": [1, 2]}
        result = next(iter(df.iterfeatures(na="drop"))).get("properties")
        assert expected == result
        # keep
        expected = {"non-scalar": [1, 2], "test_col": None}
        result = next(iter(df.iterfeatures(na="keep"))).get("properties")
        assert expected == result

    def test_geodataframe_geojson_no_bbox(self):
        geo = self.df.to_geo_dict(na="null", show_bbox=False)
        assert "bbox" not in geo.keys()
        for feature in geo["features"]:
            assert "bbox" not in feature.keys()

    def test_geodataframe_geojson_bbox(self):
        geo = self.df.to_geo_dict(na="null", show_bbox=True)
        assert "bbox" in geo.keys()
        assert len(geo["bbox"]) == 4
        assert isinstance(geo["bbox"], tuple)
        for bound in geo["bbox"]:
            assert not isinstance(bound, np.float64)
        for feature in geo["features"]:
            assert "bbox" in feature.keys()

    def test_pickle(self):
        import pickle

        df2 = pickle.loads(pickle.dumps(self.df))
        assert_geodataframe_equal(self.df, df2)

    def test_pickle_method(self):
        filename = os.path.join(self.tempdir, "df.pkl")
        self.df.to_pickle(filename)
        unpickled = pd.read_pickle(filename)
        assert_frame_equal(self.df, unpickled)
        assert self.df.crs == unpickled.crs

    def test_estimate_utm_crs(self):
        pyproj = pytest.importorskip("pyproj")

        assert self.df.estimate_utm_crs() == pyproj.CRS("EPSG:32618")
        assert self.df.estimate_utm_crs("NAD83") == pyproj.CRS("EPSG:26918")

    def test_to_wkb(self):
        wkbs0 = [
            (  # POINT (0 0)
                b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
            ),
            (  # POINT (1 1)
                b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00"
                b"\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?"
            ),
        ]
        wkbs1 = [
            (  # POINT (2 2)
                b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00"
                b"\x00\x00@\x00\x00\x00\x00\x00\x00\x00@"
            ),
            (  # POINT (3 3)
                b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00"
                b"\x00\x08@\x00\x00\x00\x00\x00\x00\x08@"
            ),
        ]
        gs0 = GeoSeries.from_wkb(wkbs0)
        gs1 = GeoSeries.from_wkb(wkbs1)
        gdf = GeoDataFrame({"geom_col0": gs0, "geom_col1": gs1})

        expected_df = pd.DataFrame({"geom_col0": wkbs0, "geom_col1": wkbs1})
        assert_frame_equal(expected_df, gdf.to_wkb())

    def test_to_wkt(self):
        wkts0 = ["POINT (0 0)", "POINT (1 1)"]
        wkts1 = ["POINT (2 2)", "POINT (3 3)"]
        gs0 = GeoSeries.from_wkt(wkts0)
        gs1 = GeoSeries.from_wkt(wkts1)
        gdf = GeoDataFrame({"gs0": gs0, "gs1": gs1})

        expected_df = pd.DataFrame({"gs0": wkts0, "gs1": wkts1})
        assert_frame_equal(expected_df, gdf.to_wkt())

    @pytest.mark.parametrize("how", ["left", "inner", "right"])
    @pytest.mark.parametrize("predicate", ["intersects", "within", "contains"])
    def test_sjoin(self, how, predicate, naturalearth_cities, naturalearth_lowres):
        """
        Basic test for availability of the GeoDataFrame method. Other
        sjoin tests are located in /tools/tests/test_sjoin.py
        """
        left = read_file(naturalearth_cities)
        right = read_file(naturalearth_lowres)

        expected = geopandas.sjoin(left, right, how=how, predicate=predicate)
        result = left.sjoin(right, how=how, predicate=predicate)
        assert_geodataframe_equal(result, expected)

    @pytest.mark.parametrize("how", ["left", "inner", "right"])
    @pytest.mark.parametrize("distance", [0, 3])
    @pytest.mark.skipif(
        not compat.GEOS_GE_310,
        reason="`dwithin` requires GEOS 3.10",
    )
    def test_sjoin_dwithin(self, how, distance):
        """
        Basic test for predicate='dwithin' availability of the GeoDataFrame method.
        Other sjoin tests are located in /tools/tests/test_sjoin.py
        """
        left = GeoDataFrame(geometry=points_from_xy([0, 1, 2], [0, 1, 1]))
        right = GeoDataFrame(geometry=[box(0, 0, 1, 1)])

        expected = geopandas.sjoin(
            left, right, how=how, predicate="dwithin", distance=distance
        )
        result = left.sjoin(right, how=how, predicate="dwithin", distance=distance)
        assert_geodataframe_equal(result, expected)

    @pytest.mark.parametrize("how", ["left", "inner", "right"])
    @pytest.mark.parametrize("max_distance", [None, 1])
    @pytest.mark.parametrize("distance_col", [None, "distance"])
    @pytest.mark.filterwarnings("ignore:Geometry is in a geographic CRS:UserWarning")
    def test_sjoin_nearest(
        self, how, max_distance, distance_col, naturalearth_cities, naturalearth_lowres
    ):
        """
        Basic test for availability of the GeoDataFrame method. Other
        sjoin tests are located in /tools/tests/test_sjoin.py
        """
        left = read_file(naturalearth_cities)
        right = read_file(naturalearth_lowres)

        expected = geopandas.sjoin_nearest(
            left, right, how=how, max_distance=max_distance, distance_col=distance_col
        )
        result = left.sjoin_nearest(
            right, how=how, max_distance=max_distance, distance_col=distance_col
        )
        assert_geodataframe_equal(result, expected)

    def test_clip(self, naturalearth_cities, naturalearth_lowres):
        """
        Basic test for availability of the GeoDataFrame method. Other
        clip tests are located in /tools/tests/test_clip.py
        """
        left = read_file(naturalearth_cities)
        world = read_file(naturalearth_lowres)
        south_america = world[world["continent"] == "South America"]

        expected = geopandas.clip(left, south_america)
        result = left.clip(south_america)
        assert_geodataframe_equal(result, expected)

    def test_clip_sorting(self, naturalearth_cities, naturalearth_lowres):
        """
        Test sorting of geodataframe when clipping.
        """
        cities = read_file(naturalearth_cities)
        world = read_file(naturalearth_lowres)
        south_america = world[world["continent"] == "South America"]

        unsorted_clipped_cities = geopandas.clip(cities, south_america, sort=False)
        sorted_clipped_cities = geopandas.clip(cities, south_america, sort=True)

        expected_sorted_index = pd.Index(
            [55, 59, 62, 88, 101, 114, 122, 169, 181, 189, 210, 230, 236, 238, 239]
        )

        assert not (
            sorted(unsorted_clipped_cities.index) == unsorted_clipped_cities.index
        ).all()
        assert (
            sorted(sorted_clipped_cities.index) == sorted_clipped_cities.index
        ).all()
        assert_index_equal(expected_sorted_index, sorted_clipped_cities.index)

    def test_overlay(self, dfs, how):
        """
        Basic test for availability of the GeoDataFrame method. Other
        overlay tests are located in tests/test_overlay.py
        """
        df1, df2 = dfs

        expected = geopandas.overlay(df1, df2, how=how)
        result = df1.overlay(df2, how=how)
        assert_geodataframe_equal(result, expected)


def check_geodataframe(df, geometry_column="geometry"):
    assert isinstance(df, GeoDataFrame)
    assert isinstance(df.geometry, GeoSeries)
    assert isinstance(df[geometry_column], GeoSeries)
    assert df._geometry_column_name == geometry_column
    assert df.geometry.name == geometry_column
    assert isinstance(df.geometry.values, GeometryArray)
    assert isinstance(df.geometry.dtype, GeometryDtype)


class TestConstructor:
    def test_dict(self):
        data = {
            "A": range(3),
            "B": np.arange(3.0),
            "geometry": [Point(x, x) for x in range(3)],
        }
        df = GeoDataFrame(data)
        check_geodataframe(df)

        # with specifying other kwargs
        df = GeoDataFrame(data, index=list("abc"))
        check_geodataframe(df)
        assert_index_equal(df.index, pd.Index(list("abc")))

        df = GeoDataFrame(data, columns=["B", "A", "geometry"])
        check_geodataframe(df)
        assert_index_equal(df.columns, pd.Index(["B", "A", "geometry"]))

        df = GeoDataFrame(data, columns=["A", "geometry"])
        check_geodataframe(df)
        assert_index_equal(df.columns, pd.Index(["A", "geometry"]))
        assert_series_equal(df["A"], pd.Series(range(3), name="A"))

    def test_dict_of_series(self):
        data = {
            "A": pd.Series(range(3)),
            "B": pd.Series(np.arange(3.0)),
            "geometry": GeoSeries([Point(x, x) for x in range(3)]),
        }

        df = GeoDataFrame(data)
        check_geodataframe(df)

        df = GeoDataFrame(data, index=pd.Index([1, 2]))
        check_geodataframe(df)
        assert_index_equal(df.index, pd.Index([1, 2]))
        assert df["A"].tolist() == [1, 2]

        # one non-series -> length is not correct
        data = {
            "A": pd.Series(range(3)),
            "B": np.arange(3.0),
            "geometry": GeoSeries([Point(x, x) for x in range(3)]),
        }
        with pytest.raises(ValueError):
            GeoDataFrame(data, index=[1, 2])

    def test_dict_specified_geometry(self):
        data = {
            "A": range(3),
            "B": np.arange(3.0),
            "other_geom": [Point(x, x) for x in range(3)],
        }

        df = GeoDataFrame(data, geometry="other_geom")
        check_geodataframe(df, "other_geom")

        with pytest.raises(ValueError):
            df = GeoDataFrame(data, geometry="geometry")

        # when no geometry specified -> works but raises error once
        # trying to access geometry
        df = GeoDataFrame(data)

        with pytest.raises(AttributeError):
            _ = df.geometry

        df = df.set_geometry("other_geom")
        check_geodataframe(df, "other_geom")

        # combined with custom args
        df = GeoDataFrame(data, geometry="other_geom", columns=["B", "other_geom"])
        check_geodataframe(df, "other_geom")
        assert_index_equal(df.columns, pd.Index(["B", "other_geom"]))
        assert_series_equal(df["B"], pd.Series(np.arange(3.0), name="B"))

        df = GeoDataFrame(data, geometry="other_geom", columns=["other_geom", "A"])
        check_geodataframe(df, "other_geom")
        assert_index_equal(df.columns, pd.Index(["other_geom", "A"]))
        assert_series_equal(df["A"], pd.Series(range(3), name="A"))

    def test_array(self):
        data = {
            "A": range(3),
            "B": np.arange(3.0),
            "geometry": [Point(x, x) for x in range(3)],
        }
        a = np.array([data["A"], data["B"], data["geometry"]], dtype=object).T

        df = GeoDataFrame(a, columns=["A", "B", "geometry"])
        check_geodataframe(df)

        df = GeoDataFrame(a, columns=["A", "B", "other_geom"], geometry="other_geom")
        check_geodataframe(df, "other_geom")

    def test_from_frame(self):
        data = {
            "A": range(3),
            "B": np.arange(3.0),
            "geometry": [Point(x, x) for x in range(3)],
        }
        gpdf = GeoDataFrame(data)
        pddf = pd.DataFrame(data)
        check_geodataframe(gpdf)
        assert type(pddf) is pd.DataFrame

        for df in [gpdf, pddf]:
            res = GeoDataFrame(df)
            check_geodataframe(res)

            res = GeoDataFrame(df, index=pd.Index([0, 2]))
            check_geodataframe(res)
            assert_index_equal(res.index, pd.Index([0, 2]))
            assert res["A"].tolist() == [0, 2]

            res = GeoDataFrame(df, columns=["geometry", "B"])
            check_geodataframe(res)
            assert_index_equal(res.columns, pd.Index(["geometry", "B"]))

            with pytest.raises(ValueError):
                GeoDataFrame(df, geometry="other_geom")

    def test_from_frame_specified_geometry(self):
        data = {
            "A": range(3),
            "B": np.arange(3.0),
            "other_geom": [Point(x, x) for x in range(3)],
        }

        gpdf = GeoDataFrame(data, geometry="other_geom")
        check_geodataframe(gpdf, "other_geom")
        pddf = pd.DataFrame(data)

        for df in [gpdf, pddf]:
            res = GeoDataFrame(df, geometry="other_geom")
            check_geodataframe(res, "other_geom")

        # gdf from gdf should preserve active geometry column name
        df = GeoDataFrame(gpdf)
        check_geodataframe(df, "other_geom")

    def test_only_geometry(self):
        exp = GeoDataFrame(
            {"geometry": [Point(x, x) for x in range(3)], "other": range(3)}
        )[["geometry"]]

        df = GeoDataFrame(geometry=[Point(x, x) for x in range(3)])
        check_geodataframe(df)
        assert_geodataframe_equal(df, exp)

        df = GeoDataFrame({"geometry": [Point(x, x) for x in range(3)]})
        check_geodataframe(df)
        assert_geodataframe_equal(df, exp)

        df = GeoDataFrame(
            {"other_geom": [Point(x, x) for x in range(3)]}, geometry="other_geom"
        )
        check_geodataframe(df, "other_geom")
        exp = exp.rename(columns={"geometry": "other_geom"}).set_geometry("other_geom")
        assert_geodataframe_equal(df, exp)

    def test_no_geometries(self):
        # keeps GeoDataFrame class (no DataFrame)
        data = {"A": range(3), "B": np.arange(3.0)}
        df = GeoDataFrame(data)
        assert type(df) is GeoDataFrame

        gdf = GeoDataFrame({"x": [1]})
        assert list(gdf.x) == [1]

    def test_empty(self):
        df = GeoDataFrame()
        assert type(df) is GeoDataFrame

        df = GeoDataFrame({"A": [], "B": []}, geometry=[])
        assert type(df) is GeoDataFrame

    def test_column_ordering(self):
        geoms = [Point(1, 1), Point(2, 2), Point(3, 3)]
        gs = GeoSeries(geoms)
        gdf = GeoDataFrame(
            {"a": [1, 2, 3], "geometry": gs},
            columns=["geometry", "a"],
            geometry="geometry",
        )
        check_geodataframe(gdf)
        assert list(gdf.columns) == ["geometry", "a"]

        # with non-default index
        gdf = GeoDataFrame(
            {"a": [1, 2, 3], "geometry": gs},
            columns=["geometry", "a"],
            index=pd.Index([0, 0, 1]),
            geometry="geometry",
        )
        check_geodataframe(gdf)
        assert list(gdf.columns) == ["geometry", "a"]

    def test_do_not_preserve_series_name_in_constructor(self):
        # GH3337
        # GeoDataFrame(... geometry=...) should always create geom col "geometry"
        geoms = [Point(1, 1), Point(2, 2), Point(3, 3)]
        gs = GeoSeries(geoms)
        gdf = GeoDataFrame({"a": [1, 2, 3]}, geometry=gs)
        check_geodataframe(gdf, geometry_column="geometry")
        # still get "geometry", even with custom geoseries name
        gs = GeoSeries(geoms, name="my_geom")
        gdf = GeoDataFrame({"a": [1, 2, 3]}, geometry=gs)
        check_geodataframe(gdf, geometry_column="geometry")

    def test_overwrite_geometry(self):
        # GH602
        data = pd.DataFrame({"geometry": [1, 2, 3], "col1": [4, 5, 6]})
        geoms = pd.Series([Point(i, i) for i in range(3)])
        # passed geometry kwarg should overwrite geometry column in data
        res = GeoDataFrame(data, geometry=geoms)
        assert_geoseries_equal(res.geometry, GeoSeries(geoms))

    def test_repeat_geo_col(self):
        df = pd.DataFrame(
            [
                {"geometry": Point(x, y), "geom": Point(x, y)}
                for x, y in zip(range(3), range(3))
            ],
        )
        # explicitly prevent construction of gdf with repeat geometry column names
        # two columns called "geometry", geom col inferred
        df2 = df.rename(columns={"geom": "geometry"})
        with pytest.raises(ValueError):
            GeoDataFrame(df2)
        # ensure case is caught when custom geom column name is used
        # two columns called "geom", geom col explicit
        df3 = df.rename(columns={"geometry": "geom"})
        with pytest.raises(ValueError):
            GeoDataFrame(df3, geometry="geom")

    @pytest.mark.parametrize("dtype", ["geometry", "object"])
    def test_multiindex_with_geometry_label(self, dtype):
        # DataFrame with MultiIndex where "geometry" label corresponds to
        # multiple columns
        df = pd.DataFrame([[Point(0, 0), Point(1, 1)], [Point(2, 2), Point(3, 3)]])
        df = df.astype(dtype)
        df.columns = pd.MultiIndex.from_product([["geometry"], [0, 1]])
        # don't error in constructor
        gdf = GeoDataFrame(df)
        with pytest.raises(AttributeError, match=".*geometry .* has not been set.*"):
            gdf.geometry
        res_gdf = gdf.set_geometry(("geometry", 0))
        assert res_gdf.shape == gdf.shape
        assert isinstance(res_gdf.geometry, GeoSeries)

    def test_default_geo_colname_none(self):
        match = "You are adding a column named 'geometry' to a GeoDataFrame"
        gdf = GeoDataFrame({"a": [1, 2]})

        gdf2 = gdf.copy()
        geo_col = GeoSeries.from_xy([1, 3], [3, 3])
        with pytest.warns(FutureWarning, match=match):
            gdf2["geometry"] = geo_col
        assert gdf2._geometry_column_name == "geometry"
        gdf4 = gdf.copy()
        with pytest.warns(FutureWarning, match=match):
            gdf4.geometry = geo_col
        assert gdf4._geometry_column_name == "geometry"

        # geo col name should only change if we add geometry
        gdf5 = gdf.copy()
        with pytest.warns(
            UserWarning, match="Geometry column does not contain geometry"
        ):
            gdf5["geometry"] = "foo"
        assert gdf5._geometry_column_name is None
        with pytest.warns(FutureWarning, match=match):
            gdf3 = gdf.copy().assign(geometry=geo_col)
        assert gdf3._geometry_column_name == "geometry"

        # Check that adding a GeoSeries to a column called "geometry" to a
        # gdf without an active geometry column some time after the init does not
        # warn / set the active geometry column
        gdf6 = gdf.copy()
        gdf6["geom2"] = geo_col
        gdf6["geom3"] = geo_col
        gdf6 = gdf6.set_geometry("geom2")
        subset = gdf6[["a", "geom3"]]  # this has a missing active geometry col
        assert subset._geometry_column_name == "geom2"
        subset["geometry"] = geo_col
        # adding column called geometry shouldn't auto-set
        assert subset._geometry_column_name == "geom2"

    def test_multiindex_geometry_colname_2_level(self):
        # GH1763 https://github.com/geopandas/geopandas/issues/1763
        crs = "EPSG:4326"
        df = pd.DataFrame(
            [[1, 0], [0, 1]], columns=[["location", "location"], ["x", "y"]]
        )
        x_col = df["location", "x"]
        y_col = df["location", "y"]

        gdf = GeoDataFrame(df, crs=crs, geometry=points_from_xy(x_col, y_col))
        if compat.HAS_PYPROJ:
            assert gdf.crs == crs
            assert gdf.geometry.crs == crs
        assert gdf.geometry.dtype == "geometry"
        assert gdf._geometry_column_name == "geometry"
        assert gdf.geometry.name == "geometry"

    def test_multiindex_geometry_colname_3_level(self):
        # GH1763 https://github.com/geopandas/geopandas/issues/1763
        # Note 3-level case uses different code paths in pandas, it is not redundant
        crs = "EPSG:4326"
        df = pd.DataFrame(
            [[1, 0], [0, 1]],
            columns=[
                ["foo", "foo"],
                ["location", "location"],
                ["x", "y"],
            ],
        )

        x_col = df["foo", "location", "x"]
        y_col = df["foo", "location", "y"]

        gdf = GeoDataFrame(df, crs=crs, geometry=points_from_xy(x_col, y_col))
        if compat.HAS_PYPROJ:
            assert gdf.crs == crs
            assert gdf.geometry.crs == crs
        assert gdf.geometry.dtype == "geometry"
        assert gdf._geometry_column_name == "geometry"
        assert gdf.geometry.name == "geometry"

    def test_multiindex_geometry_colname_3_level_new_col(self):
        crs = "EPSG:4326"
        df = pd.DataFrame(
            [[1, 0], [0, 1]],
            columns=[
                ["foo", "foo"],
                ["location", "location"],
                ["x", "y"],
            ],
        )

        x_col = df["foo", "location", "x"]
        y_col = df["foo", "location", "y"]
        df["geometry"] = GeoSeries.from_xy(x_col, y_col)
        df2 = df.copy()
        gdf = df.set_geometry("geometry", crs=crs)
        if compat.HAS_PYPROJ:
            assert gdf.crs == crs
        assert gdf._geometry_column_name == "geometry"
        assert gdf.geometry.name == "geometry"
        # test again setting with tuple col name
        gdf = df2.set_geometry(("geometry", "", ""), crs=crs)
        if compat.HAS_PYPROJ:
            assert gdf.crs == crs
        assert gdf._geometry_column_name == ("geometry", "", "")
        assert gdf.geometry.name == ("geometry", "", "")

    def test_assign_cols_using_index(self, nybb_filename):
        df = read_file(nybb_filename)
        other_df = pd.DataFrame({"foo": range(5), "bar": range(5)})
        expected = pd.concat([df, other_df], axis=1)
        df[other_df.columns] = other_df
        assert_geodataframe_equal(df, expected)

    def test_geometry_colname_enum(self):
        # ensure that other classes to geometry arg in GeoDataFrame
        # with `name` attribute are not assumed to be (Geo)Series
        class Fruit(Enum):
            apple = 1
            pear = 2

        df = pd.DataFrame(
            {Fruit.apple: [1, 2], Fruit.pear: GeoSeries.from_xy([1, 2], [3, 4])}
        )
        res = GeoDataFrame(df, geometry=Fruit.pear)
        assert res.active_geometry_name == Fruit.pear

    def test_geometry_nan_scalar(self):
        gdf = GeoDataFrame(
            data=[[np.nan, np.nan]],
            columns=["geometry", "something"],
            crs="EPSG:4326",
        )
        assert gdf.shape == (1, 2)
        assert gdf.active_geometry_name == "geometry"
        assert gdf.geometry[0] is None
        if compat.HAS_PYPROJ:
            assert gdf.crs == "EPSG:4326"

    def test_geometry_nan_array(self):
        gdf = GeoDataFrame(
            {
                "geometry": [np.nan, None, pd.NA],
                "something": [np.nan, np.nan, np.nan],
            },
            crs="EPSG:4326",
        )
        assert gdf.shape == (3, 2)
        assert gdf.active_geometry_name == "geometry"
        assert gdf.geometry.isna().all()
        if compat.HAS_PYPROJ:
            assert gdf.crs == "EPSG:4326"


@pytest.mark.skipif(not compat.HAS_PYPROJ, reason="pyproj not available")
def test_geodataframe_crs():
    gdf = GeoDataFrame(columns=["geometry"])
    gdf.crs = "IGNF:ETRS89UTM28"
    assert gdf.crs.to_authority() == ("IGNF", "ETRS89UTM28")


def test_geodataframe_nocrs_json():
    # no CRS, no crs field
    gdf = GeoDataFrame(columns=["geometry"])
    gdf_geojson = json.loads(gdf.to_json())
    assert "crs" not in gdf_geojson

    # WGS84, no crs field (default as per spec)
    gdf.crs = 4326
    gdf_geojson = json.loads(gdf.to_json())
    assert "crs" not in gdf_geojson


@pytest.mark.skipif(not compat.HAS_PYPROJ, reason="pyproj not available")
def test_geodataframe_crs_json():
    gdf = GeoDataFrame(columns=["geometry"])
    gdf.crs = 25833
    gdf_geojson = json.loads(gdf.to_json())
    assert "crs" in gdf_geojson
    assert gdf_geojson["crs"] == {
        "type": "name",
        "properties": {"name": "urn:ogc:def:crs:EPSG::25833"},
    }
    gdf_geointerface = gdf.__geo_interface__
    assert "crs" not in gdf_geointerface


@pytest.mark.skipif(not compat.HAS_PYPROJ, reason="pyproj not available")
@pytest.mark.parametrize(
    "crs",
    ["+proj=cea +lon_0=0 +lat_ts=45 +x_0=0 +y_0=0 +ellps=WGS84 +units=m", "IGNF:WGS84"],
)
def test_geodataframe_crs_nonrepresentable_json(crs):
    gdf = GeoDataFrame(
        [Point(1000, 1000)],
        columns=["geometry"],
        crs=crs,
    )
    with pytest.warns(
        UserWarning, match="GeoDataFrame's CRS is not representable in URN OGC"
    ):
        gdf_geojson = json.loads(gdf.to_json())
    assert "crs" not in gdf_geojson


def test_geodataframe_crs_colname():
    # https://github.com/geopandas/geopandas/issues/2942
    gdf = GeoDataFrame({"crs": [1], "geometry": [Point(1, 1)]})
    assert gdf.crs is None
    assert gdf["crs"].iloc[0] == 1
    assert getattr(gdf, "crs") is None

    # https://github.com/geopandas/geopandas/issues/3501
    gdf = GeoDataFrame({"crs": [1]}, geometry=[Point(1, 1)])
    assert gdf.crs is None
    assert gdf["crs"].iloc[0] == 1
    assert getattr(gdf, "crs") is None

    # test multiindex handling
    df = pd.DataFrame([[1, 0], [0, 1]], columns=[["crs", "crs"], ["x", "y"]])
    x_col = df["crs", "x"]
    y_col = df["crs", "y"]

    gdf = GeoDataFrame(df, geometry=points_from_xy(x_col, y_col))
    assert gdf.crs is None
    assert gdf["crs"].iloc[0].to_list() == [1, 0]
    assert getattr(gdf, "crs") is None


@pytest.mark.parametrize("geo_col_name", ["geometry", "polygons"])
def test_set_geometry_supply_colname(dfs, geo_col_name):
    df, _ = dfs
    if geo_col_name != "geometry":
        df = df.rename_geometry(geo_col_name)
    df["centroid"] = df.geometry.centroid
    res = df.set_geometry("centroid")
    assert res.active_geometry_name == "centroid"
    assert geo_col_name in res.columns

    # Test that drop=False explicitly warns
    deprecated = "The `drop` keyword argument is deprecated"
    with pytest.warns(FutureWarning, match=deprecated):
        res2 = df.set_geometry("centroid", drop=False)
    assert_geodataframe_equal(res, res2)

    with pytest.warns(FutureWarning, match=deprecated):
        res3 = df.set_geometry("centroid", drop=True)
    # drop=True should preserve previous geometry col name (keep old behaviour)
    assert res3.active_geometry_name == geo_col_name
    assert "centroid" not in res3.columns

    # Test that alternative suggested without using drop=True is equivalent
    assert_geodataframe_equal(
        res3,
        df.set_geometry("centroid")
        .drop(columns=geo_col_name)
        .rename_geometry(geo_col_name),
    )


@pytest.mark.parametrize("geo_col_name", ["geometry", "polygons"])
def test_set_geometry_supply_arraylike(dfs, geo_col_name):
    df, _ = dfs
    if geo_col_name != "geometry":
        df = df.rename_geometry(geo_col_name)
    centroids = df.geometry.centroid
    res = df.set_geometry(centroids)
    assert res.active_geometry_name == geo_col_name
    # drop should do nothing if the column already exists
    match_str = (
        "The `drop` keyword argument is deprecated and has no effect when "
        "`col` is an array-like value"
    )
    with pytest.warns(
        FutureWarning,
        match=match_str,
    ):
        res2 = df.set_geometry(centroids, drop=True)
    assert res2.active_geometry_name == geo_col_name

    centroids = centroids.rename("centroids")
    res3 = df.set_geometry(centroids)
    # Should preserve the geoseries name
    # (and old geometry column should be kept)
    assert res3.active_geometry_name == "centroids"
    assert geo_col_name in res3.columns

    # Drop should not remove previous active geometry colname for arraylike inputs
    with pytest.warns(
        FutureWarning,
        match=match_str,
    ):
        res4 = df.set_geometry(centroids, drop=True)
    assert res4.active_geometry_name == "centroids"
    assert geo_col_name in res4.columns


@pytest.mark.filterwarnings("error::FutureWarning")
def test_reduce_geometry_array():
    """
    Check for a FutureWarning.

    `geopandas.array.GeometryArray._reduce` issues a FutureWarning if
    the parameter `keepdims` is not set.
    `GeometryArray` inherits from `pandas.api.extensions.ExtensionArray`
    and its `_reduce` is overridden in `GeometryArray`.
    This warning is issued with pandas 2.2.2 (tested).
    """
    GeoDataFrame({"geometry": []}).all()


class GDFChild(GeoDataFrame):
    def custom_method(self):
        return "this is a custom output"


def test_inheritance(dfs):
    df, _ = dfs
    df.loc[:, "col2"] = ["a"] * len(df)

    dfc = GDFChild(df)

    dfc2 = dfc.rename_geometry("geometry2")

    children = [
        dfc,
        dfc.iloc[[0]],
        dfc.loc[dfc.col1 == 1],
        dfc.dissolve(),
        dfc[["col2", "geometry"]],
        dfc.copy(),
        dfc2,
        dfc2.iloc[[0]],
        dfc2.loc[dfc.col1 == 1],
        dfc2.dissolve(),
        dfc2[["col2", "geometry2"]],
        dfc2.copy(),
    ]

    for v in children:
        assert isinstance(v, GDFChild)
        assert v.custom_method() == "this is a custom output"

    df2 = dfc2.drop(columns=["geometry2"])

    assert not isinstance(df2, GDFChild)